Merge remote-tracking branch 'origin/main' into DRTVWR-600-maint-A

# Conflicts:
#	autobuild.xml
#	indra/cmake/CMakeLists.txt
#	indra/cmake/GoogleMock.cmake
#	indra/llaudio/llaudioengine_fmodstudio.cpp
#	indra/llaudio/llaudioengine_fmodstudio.h
#	indra/llaudio/lllistener_fmodstudio.cpp
#	indra/llaudio/lllistener_fmodstudio.h
#	indra/llaudio/llstreamingaudio_fmodstudio.cpp
#	indra/llaudio/llstreamingaudio_fmodstudio.h
#	indra/llcharacter/llmultigesture.cpp
#	indra/llcharacter/llmultigesture.h
#	indra/llimage/llimage.cpp
#	indra/llimage/llimagepng.cpp
#	indra/llimage/llimageworker.cpp
#	indra/llimage/tests/llimageworker_test.cpp
#	indra/llmessage/tests/llmockhttpclient.h
#	indra/llprimitive/llgltfmaterial.h
#	indra/llrender/llfontfreetype.cpp
#	indra/llui/llcombobox.cpp
#	indra/llui/llfolderview.cpp
#	indra/llui/llfolderviewmodel.h
#	indra/llui/lllineeditor.cpp
#	indra/llui/lllineeditor.h
#	indra/llui/lltextbase.cpp
#	indra/llui/lltextbase.h
#	indra/llui/lltexteditor.cpp
#	indra/llui/lltextvalidate.cpp
#	indra/llui/lltextvalidate.h
#	indra/llui/lluictrl.h
#	indra/llui/llview.cpp
#	indra/llwindow/llwindowmacosx.cpp
#	indra/newview/app_settings/settings.xml
#	indra/newview/llappearancemgr.cpp
#	indra/newview/llappearancemgr.h
#	indra/newview/llavatarpropertiesprocessor.cpp
#	indra/newview/llavatarpropertiesprocessor.h
#	indra/newview/llbreadcrumbview.cpp
#	indra/newview/llbreadcrumbview.h
#	indra/newview/llbreastmotion.cpp
#	indra/newview/llbreastmotion.h
#	indra/newview/llconversationmodel.h
#	indra/newview/lldensityctrl.cpp
#	indra/newview/lldensityctrl.h
#	indra/newview/llface.inl
#	indra/newview/llfloatereditsky.cpp
#	indra/newview/llfloatereditwater.cpp
#	indra/newview/llfloateremojipicker.h
#	indra/newview/llfloaterimsessiontab.cpp
#	indra/newview/llfloaterprofiletexture.cpp
#	indra/newview/llfloaterprofiletexture.h
#	indra/newview/llgesturemgr.cpp
#	indra/newview/llgesturemgr.h
#	indra/newview/llimpanel.cpp
#	indra/newview/llimpanel.h
#	indra/newview/llinventorybridge.cpp
#	indra/newview/llinventorybridge.h
#	indra/newview/llinventoryclipboard.cpp
#	indra/newview/llinventoryclipboard.h
#	indra/newview/llinventoryfunctions.cpp
#	indra/newview/llinventoryfunctions.h
#	indra/newview/llinventorygallery.cpp
#	indra/newview/lllistbrowser.cpp
#	indra/newview/lllistbrowser.h
#	indra/newview/llpanelobjectinventory.cpp
#	indra/newview/llpanelprofile.cpp
#	indra/newview/llpanelprofile.h
#	indra/newview/llpreviewgesture.cpp
#	indra/newview/llsavedsettingsglue.cpp
#	indra/newview/llsavedsettingsglue.h
#	indra/newview/lltooldraganddrop.cpp
#	indra/newview/llurllineeditorctrl.cpp
#	indra/newview/llvectorperfoptions.cpp
#	indra/newview/llvectorperfoptions.h
#	indra/newview/llviewerparceloverlay.cpp
#	indra/newview/llviewertexlayer.cpp
#	indra/newview/llviewertexturelist.cpp
#	indra/newview/macmain.h
#	indra/test/test.cpp

1 files changed, 5216 insertions, 5216 deletions

diff --git a/indra/newview/llagent.cpp b/indra/newview/llagent.cpp
index e07375b0bd..f0128b95bc 100644
--- a/indra/newview/llagent.cpp
+++ b/indra/newview/llagent.cpp
@@ -1,5216 +1,5216 @@
-/** 
- * @file llagent.cpp
- * @brief LLAgent class implementation
- *
- * $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$
- */
-
-
-#include "llviewerprecompiledheaders.h"
-
-#include "llagent.h" 
-
-#include "pipeline.h"
-
-#include "llagentaccess.h"
-#include "llagentbenefits.h"
-#include "llagentcamera.h"
-#include "llagentlistener.h"
-#include "llagentwearables.h"
-#include "llagentui.h"
-#include "llappearancemgr.h"
-#include "llanimationstates.h"
-#include "llcallingcard.h"
-#include "llchannelmanager.h"
-#include "llchicletbar.h"
-#include "llconsole.h"
-#include "lldonotdisturbnotificationstorage.h"
-#include "llfirstuse.h"
-#include "llfloatercamera.h"
-#include "llfloaterimcontainer.h"
-#include "llfloaterperms.h"
-#include "llfloaterpreference.h"
-#include "llfloaterreg.h"
-#include "llfloatersnapshot.h"
-#include "llfloatertools.h"
-#include "llgroupactions.h"
-#include "llgroupmgr.h"
-#include "llhudmanager.h"
-#include "lljoystickbutton.h"
-#include "llmorphview.h"
-#include "llmoveview.h"
-#include "llnavigationbar.h" // to show/hide navigation bar when changing mouse look state
-#include "llfloaterimnearbychat.h"
-#include "llnotificationsutil.h"
-#include "llpaneltopinfobar.h"
-#include "llparcel.h"
-#include "llperfstats.h"
-#include "llrendersphere.h"
-#include "llscriptruntimeperms.h"
-#include "llsdutil.h"
-#include "llsky.h"
-#include "llslurl.h"
-#include "llsmoothstep.h"
-#include "llstartup.h"
-#include "llstatusbar.h"
-#include "llteleportflags.h"
-#include "lltool.h"
-#include "lltoolbarview.h"
-#include "lltoolpie.h"
-#include "lltoolmgr.h"
-#include "lltrans.h"
-#include "lluictrl.h"
-#include "llurlentry.h"
-#include "llviewercontrol.h"
-#include "llviewerdisplay.h"
-#include "llviewerjoystick.h"
-#include "llviewermediafocus.h"
-#include "llviewermenu.h"
-#include "llviewerobjectlist.h"
-#include "llviewerparcelmgr.h"
-#include "llviewerregion.h"
-#include "llviewerstats.h"
-#include "llviewerwindow.h"
-#include "llvoavatarself.h"
-#include "llwindow.h"
-#include "llworld.h"
-#include "llworldmap.h"
-#include "stringize.h"
-#include "llcorehttputil.h"
-#include "lluiusage.h"
-
-using namespace LLAvatarAppearanceDefines;
-
-extern LLMenuBarGL* gMenuBarView;
-
-const bool ANIMATE = true;
-const U8 AGENT_STATE_TYPING =	0x04;
-const U8 AGENT_STATE_EDITING =  0x10;
-
-// Autopilot constants
-const F32 AUTOPILOT_HEIGHT_ADJUST_DISTANCE = 8.f;			// meters
-const F32 AUTOPILOT_MIN_TARGET_HEIGHT_OFF_GROUND = 1.f;	// meters
-const F32 AUTOPILOT_MAX_TIME_NO_PROGRESS_WALK = 1.5f;		// seconds
-const F32 AUTOPILOT_MAX_TIME_NO_PROGRESS_FLY = 2.5f;		// seconds. Flying is less presize, needs a bit more time
-
-const F32 MAX_VELOCITY_AUTO_LAND_SQUARED = 4.f * 4.f;
-const F64 CHAT_AGE_FAST_RATE = 3.0;
-
-// fidget constants
-const F32 MIN_FIDGET_TIME = 8.f; // seconds
-const F32 MAX_FIDGET_TIME = 20.f; // seconds
-
-const S32 UI_FEATURE_VERSION = 1;
-// For version 1: 1 - inventory, 2 - gltf
-const S32 UI_FEATURE_FLAGS = 3;
-
-// The agent instance.
-LLAgent gAgent;
-
-class LLTeleportRequest
-{
-public:
-	enum EStatus
-	{
-		kPending,
-		kStarted,
-		kFailed,
-		kRestartPending
-	};
-
-	LLTeleportRequest();
-	virtual ~LLTeleportRequest();
-
-	EStatus getStatus() const          {return mStatus;};
-	void    setStatus(EStatus pStatus) {mStatus = pStatus;};
-
-	static std::map<S32, std::string> sTeleportStatusName;
-	static const std::string& statusName(EStatus status);
-	virtual void toOstream(std::ostream& os) const;
-
-	virtual bool canRestartTeleport();
-
-	virtual void startTeleport() = 0;
-	virtual void restartTeleport();
-
-protected:
-
-private:
-	EStatus mStatus;
-};
-
-std::map<S32, std::string> LLTeleportRequest::sTeleportStatusName = { { kPending, "kPending" },
-																	  { kStarted, "kStarted" },
-																	  { kFailed, "kFailed" },
-																	  { kRestartPending, "kRestartPending"} };
-
-class LLTeleportRequestViaLandmark : public LLTeleportRequest
-{
-public:
-	LLTeleportRequestViaLandmark(const LLUUID &pLandmarkId);
-	virtual ~LLTeleportRequestViaLandmark();
-
-	virtual void toOstream(std::ostream& os) const;
-
-	virtual bool canRestartTeleport();
-
-	virtual void startTeleport();
-	virtual void restartTeleport();
-
-protected:
-	inline const LLUUID &getLandmarkId() const {return mLandmarkId;};
-
-private:
-	LLUUID mLandmarkId;
-};
-
-class LLTeleportRequestViaLure : public LLTeleportRequestViaLandmark
-{
-public:
-	LLTeleportRequestViaLure(const LLUUID &pLureId, bool pIsLureGodLike);
-	virtual ~LLTeleportRequestViaLure();
-
-	virtual void toOstream(std::ostream& os) const;
-
-	virtual bool canRestartTeleport();
-
-	virtual void startTeleport();
-
-protected:
-	inline bool isLureGodLike() const {return mIsLureGodLike;};
-
-private:
-	bool mIsLureGodLike;
-};
-
-class LLTeleportRequestViaLocation : public LLTeleportRequest
-{
-public:
-	LLTeleportRequestViaLocation(const LLVector3d &pPosGlobal);
-	virtual ~LLTeleportRequestViaLocation();
-
-	virtual void toOstream(std::ostream& os) const;
-
-	virtual bool canRestartTeleport();
-
-	virtual void startTeleport();
-	virtual void restartTeleport();
-
-protected:
-	inline const LLVector3d &getPosGlobal() const {return mPosGlobal;};
-
-private:
-	LLVector3d mPosGlobal;
-};
-
-
-class LLTeleportRequestViaLocationLookAt : public LLTeleportRequestViaLocation
-{
-public:
-	LLTeleportRequestViaLocationLookAt(const LLVector3d &pPosGlobal);
-	virtual ~LLTeleportRequestViaLocationLookAt();
-
-	virtual void toOstream(std::ostream& os) const;
-
-	virtual bool canRestartTeleport();
-
-	virtual void startTeleport();
-	virtual void restartTeleport();
-
-protected:
-
-private:
-
-};
-
-//--------------------------------------------------------------------
-// Statics
-//
-
-/// minimum time after setting away state before coming back based on movement
-const F32 LLAgent::MIN_AFK_TIME = 10.0f;
-
-const F32 LLAgent::TYPING_TIMEOUT_SECS = 5.f;
-
-std::map<std::string, std::string> LLAgent::sTeleportErrorMessages;
-std::map<std::string, std::string> LLAgent::sTeleportProgressMessages;
-
-class LLAgentFriendObserver : public LLFriendObserver
-{
-public:
-	LLAgentFriendObserver() {}
-	virtual ~LLAgentFriendObserver() {}
-	virtual void changed(U32 mask);
-};
-
-void LLAgentFriendObserver::changed(U32 mask)
-{
-	// if there's a change we're interested in.
-	if((mask & (LLFriendObserver::POWERS)) != 0)
-	{
-		gAgent.friendsChanged();
-	}
-}
-
-bool handleSlowMotionAnimation(const LLSD& newvalue)
-{
-	if (newvalue.asBoolean())
-	{
-		gAgentAvatarp->setAnimTimeFactor(0.2f);
-	}
-	else
-	{
-		gAgentAvatarp->setAnimTimeFactor(1.0f);
-	}
-	return true;
-}
-
-void LLAgent::setCanEditParcel() // called via mParcelChangedSignal
-{
-	bool can_edit = LLToolMgr::getInstance()->canEdit();
-	gAgent.mCanEditParcel = can_edit;
-}
-
-// static
-bool LLAgent::isActionAllowed(const LLSD& sdname)
-{
-	bool retval = false;
-
-	const std::string& param = sdname.asString();
-
-	if (param == "speak")
-	{
-        bool allow_agent_voice = false;
-        LLVoiceChannel* channel = LLVoiceChannel::getCurrentVoiceChannel();
-        if (channel != NULL)
-        {
-            if (channel->getSessionName().empty() && channel->getSessionID().isNull())
-            {
-                // default channel
-                allow_agent_voice = LLViewerParcelMgr::getInstance()->allowAgentVoice();
-            }
-            else
-            {
-                allow_agent_voice = channel->isActive() && channel->callStarted();
-            }
-        }
-
-        if (gAgent.isVoiceConnected() &&
-            allow_agent_voice &&
-            !LLVoiceClient::getInstance()->inTuningMode())
-		{
-			retval = true;
-		}
-		else
-		{
-			retval = false;
-		}
-	}
-
-	return retval;
-}
-
-// static 
-void LLAgent::pressMicrophone(const LLSD& name)
-{
-	LLFirstUse::speak(false);
-
-	 LLVoiceClient::getInstance()->inputUserControlState(true);
-}
-
-// static 
-void LLAgent::releaseMicrophone(const LLSD& name)
-{
-	LLVoiceClient::getInstance()->inputUserControlState(false);
-}
-
-// static
-void LLAgent::toggleMicrophone(const LLSD& name)
-{
-	LLVoiceClient::getInstance()->toggleUserPTTState();
-}
-
-// static
-bool LLAgent::isMicrophoneOn(const LLSD& sdname)
-{
-	return LLVoiceClient::getInstance()->getUserPTTState();
-}
-
-// ************************************************************
-// Enabled this definition to compile a 'hacked' viewer that
-// locally believes the end user has godlike powers.
-// #define HACKED_GODLIKE_VIEWER
-// For a toggled version, see viewer.h for the
-// TOGGLE_HACKED_GODLIKE_VIEWER define, instead.
-// ************************************************************
-
-// Constructors and Destructors
-
-// JC - Please try to make this order match the order in the header
-// file.  Otherwise it's hard to find variables that aren't initialized.
-//-----------------------------------------------------------------------------
-// LLAgent()
-//-----------------------------------------------------------------------------
-LLAgent::LLAgent() :
-	mGroupPowers(0),
-	mHideGroupTitle(false),
-	mGroupID(),
-
-	mInitialized(false),
-	mListener(),
-
-	mDoubleTapRunTimer(),
-	mDoubleTapRunMode(DOUBLETAP_NONE),
-
-	mbAlwaysRun(false),
-	mbRunning(false),
-	mbTeleportKeepsLookAt(false),
-
-	mAgentAccess(new LLAgentAccess(gSavedSettings)),
-	mGodLevelChangeSignal(),
-	mCanEditParcel(false),
-	mTeleportSourceSLURL(new LLSLURL),
-	mTeleportRequest(),
-	mTeleportFinishedSlot(),
-	mTeleportFailedSlot(),
-	mIsMaturityRatingChangingDuringTeleport(false),
-	mTPNeedsNeabyChatSeparator(false),
-	mMaturityRatingChange(0U),
-	mIsDoSendMaturityPreferenceToServer(false),
-	mMaturityPreferenceRequestId(0U),
-	mMaturityPreferenceResponseId(0U),
-	mMaturityPreferenceNumRetries(0U),
-	mLastKnownRequestMaturity(SIM_ACCESS_MIN),
-	mLastKnownResponseMaturity(SIM_ACCESS_MIN),
-	mHttpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID),
-	mTeleportState(TELEPORT_NONE),
-	mRegionp(NULL),
-    mInterestListMode(IL_MODE_DEFAULT),
-
-	mAgentOriginGlobal(),
-	mPositionGlobal(),
-    mLastTestGlobal(),
-
-	mDistanceTraveled(0.F),
-	mLastPositionGlobal(LLVector3d::zero),
-
-	mRenderState(0),
-	mTypingTimer(),
-
-	mViewsPushed(false),
-
-	mCustomAnim(false),
-	mShowAvatar(true),
-	mFrameAgent(),
-
-	mIsDoNotDisturb(false),
-
-	mControlFlags(0x00000000),
-	mbFlagsDirty(false),
-	mbFlagsNeedReset(false),
-
-	mAutoPilot(false),
-	mAutoPilotFlyOnStop(false),
-	mAutoPilotAllowFlying(true),
-	mAutoPilotTargetGlobal(),
-	mAutoPilotStopDistance(1.f),
-	mAutoPilotUseRotation(false),
-	mAutoPilotTargetFacing(LLVector3::zero),
-	mAutoPilotTargetDist(0.f),
-	mAutoPilotNoProgressFrameCount(0),
-	mAutoPilotRotationThreshold(0.f),
-	mAutoPilotFinishedCallback(NULL),
-	mAutoPilotCallbackData(NULL),
-	
-	mMovementKeysLocked(false),
-
-	mEffectColor(new LLUIColor(LLColor4(0.f, 1.f, 1.f, 1.f))),
-
-	mHaveHomePosition(false),
-	mHomeRegionHandle( 0 ),
-	mNearChatRadius(CHAT_NORMAL_RADIUS / 2.f),
-
-	mNextFidgetTime(0.f),
-	mCurrentFidget(0),
-	mFirstLogin(false),
-	mOutfitChosen(false),
-
-	mVoiceConnected(false),
-
-	mMouselookModeInSignal(NULL),
-	mMouselookModeOutSignal(NULL)
-{
-	for (U32 i = 0; i < TOTAL_CONTROLS; i++)
-	{
-		mControlsTakenCount[i] = 0;
-		mControlsTakenPassedOnCount[i] = 0;
-	}
-
-	mListener.reset(new LLAgentListener(*this));
-
-	addParcelChangedCallback(&setCanEditParcel);
-
-	mMoveTimer.stop();
-}
-
-// Requires gSavedSettings to be initialized.
-//-----------------------------------------------------------------------------
-// init()
-//-----------------------------------------------------------------------------
-void LLAgent::init()
-{
-	mMoveTimer.start();
-
-	gSavedSettings.declareBOOL("SlowMotionAnimation", false, "Declared in code", LLControlVariable::PERSIST_NO);
-	gSavedSettings.getControl("SlowMotionAnimation")->getSignal()->connect(boost::bind(&handleSlowMotionAnimation, _2));
-	
-	// *Note: this is where LLViewerCamera::getInstance() used to be constructed.
-
-    bool is_flying = gSavedSettings.getBOOL("FlyingAtExit");
-    if(is_flying)
-    {
-        setFlying(is_flying);
-    }
-
-	*mEffectColor = LLUIColorTable::instance().getColor("EffectColor");
-
-	gSavedSettings.getControl("PreferredMaturity")->getValidateSignal()->connect(boost::bind(&LLAgent::validateMaturity, this, _2));
-	gSavedSettings.getControl("PreferredMaturity")->getSignal()->connect(boost::bind(&LLAgent::handleMaturity, this, _2));
-	mLastKnownResponseMaturity = static_cast<U8>(gSavedSettings.getU32("PreferredMaturity"));
-	mLastKnownRequestMaturity = mLastKnownResponseMaturity;
-	mIsDoSendMaturityPreferenceToServer = true;
-
-	if (!mTeleportFinishedSlot.connected())
-	{
-		mTeleportFinishedSlot = LLViewerParcelMgr::getInstance()->setTeleportFinishedCallback(boost::bind(&LLAgent::handleTeleportFinished, this));
-	}
-	if (!mTeleportFailedSlot.connected())
-	{
-		mTeleportFailedSlot = LLViewerParcelMgr::getInstance()->setTeleportFailedCallback(boost::bind(&LLAgent::handleTeleportFailed, this));
-	}
-
-	LLAppCoreHttp & app_core_http(LLAppViewer::instance()->getAppCoreHttp());
-
-	mHttpPolicy = app_core_http.getPolicy(LLAppCoreHttp::AP_AGENT);
-
-	mInitialized = true;
-}
-
-//-----------------------------------------------------------------------------
-// cleanup()
-//-----------------------------------------------------------------------------
-void LLAgent::cleanup()
-{
-	mRegionp = NULL;
-    mTeleportRequest = NULL;
-    mTeleportCanceled = NULL;
-	if (mTeleportFinishedSlot.connected())
-	{
-		mTeleportFinishedSlot.disconnect();
-	}
-	if (mTeleportFailedSlot.connected())
-	{
-		mTeleportFailedSlot.disconnect();
-	}
-}
-
-//-----------------------------------------------------------------------------
-// LLAgent()
-//-----------------------------------------------------------------------------
-LLAgent::~LLAgent()
-{
-	cleanup();
-
-	delete mMouselookModeInSignal;
-	mMouselookModeInSignal = NULL;
-	delete mMouselookModeOutSignal;
-	mMouselookModeOutSignal = NULL;
-
-	delete mAgentAccess;
-	mAgentAccess = NULL;
-	delete mEffectColor;
-	mEffectColor = NULL;
-	delete mTeleportSourceSLURL;
-	mTeleportSourceSLURL = NULL;
-}
-
-// Handle any actions that need to be performed when the main app gains focus
-// (such as through alt-tab).
-//-----------------------------------------------------------------------------
-// onAppFocusGained()
-//-----------------------------------------------------------------------------
-void LLAgent::onAppFocusGained()
-{
-	if (CAMERA_MODE_MOUSELOOK == gAgentCamera.getCameraMode())
-	{
-		gAgentCamera.changeCameraToDefault();
-		LLToolMgr::getInstance()->clearSavedTool();
-	}
-}
-
-void LLAgent::setFirstLogin(bool b)
-{
-    mFirstLogin = b;
-
-    if (mFirstLogin)
-    {
-        // Don't notify new users about new features
-        if (getFeatureVersion() <= UI_FEATURE_VERSION)
-        {
-            setFeatureVersion(UI_FEATURE_VERSION, UI_FEATURE_FLAGS);
-        }
-    }
-}
-
-void LLAgent::setFeatureVersion(S32 version, S32 flags)
-{
-    LLSD updated_version;
-    updated_version["version"] = version;
-    updated_version["flags"] = flags;
-    gSavedSettings.setLLSD("LastUIFeatureVersion", updated_version);
-}
-
-S32 LLAgent::getFeatureVersion()
-{
-    S32 version;
-    S32 flags;
-    getFeatureVersionAndFlags(version, flags);
-    return version;
-}
-
-void LLAgent::getFeatureVersionAndFlags(S32& version, S32& flags)
-{
-    version = 0;
-    flags = 0;
-    LLSD feature_version = gSavedSettings.getLLSD("LastUIFeatureVersion");
-    if (feature_version.isInteger())
-    {
-        version = feature_version.asInteger();
-        flags = 1; // inventory flag
-    }
-    else if (feature_version.isMap())
-    {
-        version = feature_version["version"];
-        flags = feature_version["flags"];
-    }
-    else if (!feature_version.isString() && !feature_version.isUndefined())
-    {
-        // is something newer inside?
-        version = UI_FEATURE_VERSION;
-        flags = UI_FEATURE_FLAGS;
-    }
-}
-
-void LLAgent::showLatestFeatureNotification(const std::string key)
-{
-    S32 version;
-    S32 flags; // a single release can have multiple new features
-    getFeatureVersionAndFlags(version, flags);
-    if (version <= UI_FEATURE_VERSION && (flags & UI_FEATURE_FLAGS) != UI_FEATURE_FLAGS)
-    {
-        S32 flag = 0;
-
-        if (key == "inventory")
-        {
-            // Notify user about new thumbnail support
-            flag = 1;
-        }
-
-        if (key == "gltf")
-        {
-            flag = 2;
-        }
-
-        if ((flags & flag) == 0)
-        {
-            // Need to open on top even if called from onOpen,
-            // do on idle to make sure it's on top
-            LLSD floater_key(key);
-            doOnIdleOneTime([floater_key]()
-                            {
-                                LLFloaterReg::showInstance("new_feature_notification", floater_key);
-                            });
-
-            setFeatureVersion(UI_FEATURE_VERSION, flags | flag);
-        }
-    }
-}
-
-void LLAgent::ageChat()
-{
-	if (isAgentAvatarValid())
-	{
-		// get amount of time since I last chatted
-		F64 elapsed_time = (F64)gAgentAvatarp->mChatTimer.getElapsedTimeF32();
-		// add in frame time * 3 (so it ages 4x)
-		gAgentAvatarp->mChatTimer.setAge(elapsed_time + (F64)gFrameDTClamped * (CHAT_AGE_FAST_RATE - 1.0));
-	}
-}
-
-//-----------------------------------------------------------------------------
-// moveAt()
-//-----------------------------------------------------------------------------
-void LLAgent::moveAt(S32 direction, bool reset)
-{
-	LLUIUsage::instance().logCommand("Agent.MoveAt");
-	
-	mMoveTimer.reset();
-	LLFirstUse::notMoving(false);
-
-	// age chat timer so it fades more quickly when you are intentionally moving
-	ageChat();
-
-	gAgentCamera.setAtKey(LLAgentCamera::directionToKey(direction));
-
-	if (direction > 0)
-	{
-		setControlFlags(AGENT_CONTROL_AT_POS | AGENT_CONTROL_FAST_AT);
-	}
-	else if (direction < 0)
-	{
-		setControlFlags(AGENT_CONTROL_AT_NEG | AGENT_CONTROL_FAST_AT);
-	}
-
-	if (reset)
-	{
-		gAgentCamera.resetView();
-	}
-}
-
-//-----------------------------------------------------------------------------
-// moveAtNudge()
-//-----------------------------------------------------------------------------
-void LLAgent::moveAtNudge(S32 direction)
-{
-	mMoveTimer.reset();
-	LLFirstUse::notMoving(false);
-
-	// age chat timer so it fades more quickly when you are intentionally moving
-	ageChat();
-
-	gAgentCamera.setWalkKey(LLAgentCamera::directionToKey(direction));
-
-	if (direction > 0)
-	{
-		setControlFlags(AGENT_CONTROL_NUDGE_AT_POS);
-	}
-	else if (direction < 0)
-	{
-		setControlFlags(AGENT_CONTROL_NUDGE_AT_NEG);
-	}
-
-	gAgentCamera.resetView();
-}
-
-//-----------------------------------------------------------------------------
-// moveLeft()
-//-----------------------------------------------------------------------------
-void LLAgent::moveLeft(S32 direction)
-{
-	mMoveTimer.reset();
-	LLFirstUse::notMoving(false);
-
-	// age chat timer so it fades more quickly when you are intentionally moving
-	ageChat();
-
-	gAgentCamera.setLeftKey(LLAgentCamera::directionToKey(direction));
-
-	if (direction > 0)
-	{
-		setControlFlags(AGENT_CONTROL_LEFT_POS | AGENT_CONTROL_FAST_LEFT);
-	}
-	else if (direction < 0)
-	{
-		setControlFlags(AGENT_CONTROL_LEFT_NEG | AGENT_CONTROL_FAST_LEFT);
-	}
-
-	gAgentCamera.resetView();
-}
-
-//-----------------------------------------------------------------------------
-// moveLeftNudge()
-//-----------------------------------------------------------------------------
-void LLAgent::moveLeftNudge(S32 direction)
-{
-	mMoveTimer.reset();
-	LLFirstUse::notMoving(false);
-
-	// age chat timer so it fades more quickly when you are intentionally moving
-	ageChat();
-
-	gAgentCamera.setLeftKey(LLAgentCamera::directionToKey(direction));
-
-	if (direction > 0)
-	{
-		setControlFlags(AGENT_CONTROL_NUDGE_LEFT_POS);
-	}
-	else if (direction < 0)
-	{
-		setControlFlags(AGENT_CONTROL_NUDGE_LEFT_NEG);
-	}
-
-	gAgentCamera.resetView();
-}
-
-//-----------------------------------------------------------------------------
-// moveUp()
-//-----------------------------------------------------------------------------
-void LLAgent::moveUp(S32 direction)
-{
-	mMoveTimer.reset();
-	LLFirstUse::notMoving(false);
-
-	// age chat timer so it fades more quickly when you are intentionally moving
-	ageChat();
-
-	gAgentCamera.setUpKey(LLAgentCamera::directionToKey(direction));
-
-	if (direction > 0)
-	{
-		setControlFlags(AGENT_CONTROL_UP_POS | AGENT_CONTROL_FAST_UP);
-	}
-	else if (direction < 0)
-	{
-		setControlFlags(AGENT_CONTROL_UP_NEG | AGENT_CONTROL_FAST_UP);
-	}
-
-	gAgentCamera.resetView();
-}
-
-//-----------------------------------------------------------------------------
-// moveYaw()
-//-----------------------------------------------------------------------------
-void LLAgent::moveYaw(F32 mag, bool reset_view)
-{
-	gAgentCamera.setYawKey(mag);
-
-	if (mag > 0)
-	{
-		setControlFlags(AGENT_CONTROL_YAW_POS);
-	}
-	else if (mag < 0)
-	{
-		setControlFlags(AGENT_CONTROL_YAW_NEG);
-	}
-
-    U32 mask = AGENT_CONTROL_YAW_POS | AGENT_CONTROL_YAW_NEG;
-    if ((getControlFlags() & mask) == mask)
-    {
-        // Rotation into both directions should cancel out
-        // But keep sending controls to simulator,
-        // it's needed for script based controls
-        gAgentCamera.setYawKey(0);
-    }
-
-    if (reset_view)
-	{
-        gAgentCamera.resetView();
-	}
-}
-
-//-----------------------------------------------------------------------------
-// movePitch()
-//-----------------------------------------------------------------------------
-void LLAgent::movePitch(F32 mag)
-{
-	gAgentCamera.setPitchKey(mag);
-
-	if (mag > 0)
-	{
-		setControlFlags(AGENT_CONTROL_PITCH_POS);
-	}
-	else if (mag < 0)
-	{
-		setControlFlags(AGENT_CONTROL_PITCH_NEG);
-	}
-}
-
-
-// Does this parcel allow you to fly?
-bool LLAgent::canFly()
-{
-	if (isGodlike()) return true;
-
-	LLViewerRegion* regionp = getRegion();
-	if (regionp && regionp->getBlockFly()) return false;
-	
-	LLParcel* parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
-	if (!parcel) return false;
-
-	// Allow owners to fly on their own land.
-	if (LLViewerParcelMgr::isParcelOwnedByAgent(parcel, GP_LAND_ALLOW_FLY))
-	{
-		return true;
-	}
-
-	return parcel->getAllowFly();
-}
-
-bool LLAgent::getFlying() const
-{ 
-	return mControlFlags & AGENT_CONTROL_FLY; 
-}
-
-//-----------------------------------------------------------------------------
-// setFlying()
-//-----------------------------------------------------------------------------
-void LLAgent::setFlying(bool fly, bool fail_sound)
-{
-	if (isAgentAvatarValid())
-	{
-		// *HACK: Don't allow to start the flying mode if we got ANIM_AGENT_STANDUP signal
-		// because in this case we won't get a signal to start avatar flying animation and
-		// it will be walking with flying mode "ON" indication. However we allow to switch
-		// the flying mode off if we get ANIM_AGENT_STANDUP signal. See process_avatar_animation().
-		// See EXT-2781.
-		if(fly && gAgentAvatarp->mSignaledAnimations.find(ANIM_AGENT_STANDUP) != gAgentAvatarp->mSignaledAnimations.end())
-		{
-			return;
-		}
-
-		// don't allow taking off while sitting
-		if (fly && gAgentAvatarp->isSitting())
-		{
-			return;
-		}
-	}
-
-	if (fly)
-	{
-		bool was_flying = getFlying();
-		if (!canFly() && !was_flying)
-		{
-			// parcel doesn't let you start fly
-			// gods can always fly
-			// and it's OK if you're already flying
-			if (fail_sound)
-			{
-			make_ui_sound("UISndBadKeystroke");
-			}
-			return;
-		}
-		if( !was_flying )
-		{
-			add(LLStatViewer::FLY, 1);
-		}
-		setControlFlags(AGENT_CONTROL_FLY);
-	}
-	else
-	{
-		clearControlFlags(AGENT_CONTROL_FLY);
-	}
-
-
-	// Update Movement Controls according to Fly mode
-	LLFloaterMove::setFlyingMode(fly);
-
-	mbFlagsDirty = true;
-}
-
-
-// UI based mechanism of setting fly state
-//-----------------------------------------------------------------------------
-// toggleFlying()
-//-----------------------------------------------------------------------------
-// static
-void LLAgent::toggleFlying()
-{
-	if ( gAgent.mAutoPilot )
-	{
-		LLToolPie::instance().stopClickToWalk();
-	}
-
-	bool fly = !gAgent.getFlying();
-
-	gAgent.mMoveTimer.reset();
-	LLFirstUse::notMoving(false);
-
-	gAgent.setFlying( fly );
-	gAgentCamera.resetView();
-}
-
-// static
-bool LLAgent::enableFlying()
-{
-	bool sitting = false;
-	if (isAgentAvatarValid())
-	{
-		sitting = gAgentAvatarp->isSitting();
-	}
-	return !sitting;
-}
-
-// static
-bool LLAgent::isSitting()
-{
-    bool sitting = false;
-    if (isAgentAvatarValid())
-    {
-        sitting = gAgentAvatarp->isSitting();
-    }
-    return sitting;
-}
-
-void LLAgent::standUp()
-{
-	setControlFlags(AGENT_CONTROL_STAND_UP);
-}
-
-void LLAgent::changeParcels()
-{
-	LL_DEBUGS("AgentLocation") << "Calling ParcelChanged callbacks" << LL_ENDL;
-	// Notify anything that wants to know about parcel changes
-	mParcelChangedSignal();
-}
-
-boost::signals2::connection LLAgent::addParcelChangedCallback(parcel_changed_callback_t cb)
-{
-	return mParcelChangedSignal.connect(cb);
-}
-
-// static
-void LLAgent::capabilityReceivedCallback(const LLUUID &region_id, LLViewerRegion *regionp)
-{	// Changed regions and now have the region capabilities
-    if (regionp)
-    {
-        if (regionp->getRegionID() == region_id)
-        {
-            regionp->requestSimulatorFeatures();
-            LLAppViewer::instance()->updateNameLookupUrl(regionp);
-        }
-
-        if (gAgent.getInterestListMode() == IL_MODE_360)
-        {
-            gAgent.changeInterestListMode(IL_MODE_360);
-        }
-    }
-}
-
-
-//-----------------------------------------------------------------------------
-// setRegion()
-//-----------------------------------------------------------------------------
-void LLAgent::setRegion(LLViewerRegion *regionp)
-{
-	llassert(regionp);
-	if (mRegionp != regionp)
-	{
-
-		LL_INFOS("AgentLocation","Teleport") << "Moving agent into region: handle " << regionp->getHandle() 
-											 << " id " << regionp->getRegionID()
-											 << " name " << regionp->getName()
-											 << " previous region "
-											 << (mRegionp ? mRegionp->getRegionID() : LLUUID::null)
-											 << LL_ENDL;
-		if (mRegionp)
-		{
-			// We've changed regions, we're now going to change our agent coordinate frame.
-			mAgentOriginGlobal = regionp->getOriginGlobal();
-			LLVector3d agent_offset_global = mRegionp->getOriginGlobal();
-
-			LLVector3 delta;
-			delta.setVec(regionp->getOriginGlobal() - mRegionp->getOriginGlobal());
-
-			setPositionAgent(getPositionAgent() - delta);
-
-			LLVector3 camera_position_agent = LLViewerCamera::getInstance()->getOrigin();
-			LLViewerCamera::getInstance()->setOrigin(camera_position_agent - delta);
-
-			// Update all of the regions.
-			LLWorld::getInstance()->updateAgentOffset(agent_offset_global);
-
-			// Hack to keep sky in the agent's region, otherwise it may get deleted - DJS 08/02/02
-			// *TODO: possibly refactor into gSky->setAgentRegion(regionp)? -Brad
-			if (gSky.mVOSkyp)
-			{
-				gSky.mVOSkyp->setRegion(regionp);
-			}
-			
-            if (regionp->capabilitiesReceived())
-            {
-                regionp->requestSimulatorFeatures();
-                LLAppViewer::instance()->updateNameLookupUrl(regionp);
-            }
-            else
-            {
-                regionp->setCapabilitiesReceivedCallback(LLAgent::capabilityReceivedCallback);
-            }
-
-		}
-		else
-		{
-			// First time initialization.
-			// We've changed regions, we're now going to change our agent coordinate frame.
-			mAgentOriginGlobal = regionp->getOriginGlobal();
-
-			LLVector3 delta;
-			delta.setVec(regionp->getOriginGlobal());
-
-			setPositionAgent(getPositionAgent() - delta);
-			LLVector3 camera_position_agent = LLViewerCamera::getInstance()->getOrigin();
-			LLViewerCamera::getInstance()->setOrigin(camera_position_agent - delta);
-
-			// Update all of the regions.
-			LLWorld::getInstance()->updateAgentOffset(mAgentOriginGlobal);
-
-            if (regionp->capabilitiesReceived())
-            {
-                LLAppViewer::instance()->updateNameLookupUrl(regionp);
-            }
-            else
-            {
-                regionp->setCapabilitiesReceivedCallback([](const LLUUID &region_id, LLViewerRegion* regionp) {LLAppViewer::instance()->updateNameLookupUrl(regionp); });
-            }
-		}
-
-		// Pass new region along to metrics components that care about this level of detail.
-		LLAppViewer::metricsUpdateRegion(regionp->getHandle());
-	}
-
-	mRegionp = regionp;
-
-	// TODO - most of what follows probably should be moved into callbacks
-
-	// Pass the region host to LLUrlEntryParcel to resolve parcel name
-	// with a server request.
-	LLUrlEntryParcel::setRegionHost(getRegionHost());
-
-	// Must shift hole-covering water object locations because local
-	// coordinate frame changed.
-	LLWorld::getInstance()->updateWaterObjects();
-
-	// keep a list of regions we've been too
-	// this is just an interesting stat, logged at the dataserver
-	// we could trake this at the dataserver side, but that's harder
-	U64 handle = regionp->getHandle();
-	mRegionsVisited.insert(handle);
-
-	LLSelectMgr::getInstance()->updateSelectionCenter();
-
-	LLFloaterMove::sUpdateFlyingStatus();
-
-	LL_DEBUGS("AgentLocation") << "Calling RegionChanged callbacks" << LL_ENDL;
-	mRegionChangedSignal();
-}
-
-
-//-----------------------------------------------------------------------------
-// getRegion()
-//-----------------------------------------------------------------------------
-LLViewerRegion *LLAgent::getRegion() const
-{
-	return mRegionp;
-}
-
-
-LLHost LLAgent::getRegionHost() const
-{
-	if (mRegionp)
-	{
-		return mRegionp->getHost();
-	}
-	else
-	{
-		return LLHost();
-	}
-}
-
-boost::signals2::connection LLAgent::addRegionChangedCallback(const region_changed_signal_t::slot_type& cb)
-{
-	return mRegionChangedSignal.connect(cb);
-}
-
-void LLAgent::removeRegionChangedCallback(boost::signals2::connection callback)
-{
-	mRegionChangedSignal.disconnect(callback);
-}
-
-//-----------------------------------------------------------------------------
-// inPrelude()
-//-----------------------------------------------------------------------------
-bool LLAgent::inPrelude()
-{
-	return mRegionp && mRegionp->isPrelude();
-}
-
-
-std::string LLAgent::getRegionCapability(const std::string &name)
-{
-    if (!mRegionp)
-        return std::string();
-    
-    return mRegionp->getCapability(name);
-}
-
-
-//-----------------------------------------------------------------------------
-// canManageEstate()
-//-----------------------------------------------------------------------------
-
-bool LLAgent::canManageEstate() const
-{
-	return mRegionp && mRegionp->canManageEstate();
-}
-
-//-----------------------------------------------------------------------------
-// sendMessage()
-//-----------------------------------------------------------------------------
-void LLAgent::sendMessage()
-{
-	if (gDisconnected)
-	{
-		LL_WARNS() << "Trying to send message when disconnected!" << LL_ENDL;
-		return;
-	}
-	if (!mRegionp)
-	{
-		LL_ERRS() << "No region for agent yet!" << LL_ENDL;
-		return;
-	}
-	gMessageSystem->sendMessage(mRegionp->getHost());
-}
-
-
-//-----------------------------------------------------------------------------
-// sendReliableMessage()
-//-----------------------------------------------------------------------------
-void LLAgent::sendReliableMessage()
-{
-	if (gDisconnected)
-	{
-		LL_DEBUGS() << "Trying to send message when disconnected!" << LL_ENDL;
-		return;
-	}
-	if (!mRegionp)
-	{
-		LL_DEBUGS() << "LLAgent::sendReliableMessage No region for agent yet, not sending message!" << LL_ENDL;
-		return;
-	}
-	gMessageSystem->sendReliable(mRegionp->getHost());
-}
-
-//-----------------------------------------------------------------------------
-// getVelocity()
-//-----------------------------------------------------------------------------
-LLVector3 LLAgent::getVelocity() const
-{
-	if (isAgentAvatarValid())
-	{
-		return gAgentAvatarp->getVelocity();
-	}
-	else
-	{
-		return LLVector3::zero;
-	}
-}
-
-
-//-----------------------------------------------------------------------------
-// setPositionAgent()
-//-----------------------------------------------------------------------------
-void LLAgent::setPositionAgent(const LLVector3 &pos_agent)
-{
-	if (!pos_agent.isFinite())
-	{
-		LL_ERRS() << "setPositionAgent is not a number" << LL_ENDL;
-	}
-
-	if (isAgentAvatarValid() && gAgentAvatarp->getParent())
-	{
-		LLVector3 pos_agent_sitting;
-		LLVector3d pos_agent_d;
-		LLViewerObject *parent = (LLViewerObject*)gAgentAvatarp->getParent();
-
-		pos_agent_sitting = gAgentAvatarp->getPosition() * parent->getRotation() + parent->getPositionAgent();
-		pos_agent_d.setVec(pos_agent_sitting);
-
-		mFrameAgent.setOrigin(pos_agent_sitting);
-		mPositionGlobal = pos_agent_d + mAgentOriginGlobal;
-	}
-	else
-	{
-		mFrameAgent.setOrigin(pos_agent);
-
-		LLVector3d pos_agent_d;
-		pos_agent_d.setVec(pos_agent);
-		mPositionGlobal = pos_agent_d + mAgentOriginGlobal;
-	}
-
-    if (((mLastTestGlobal - mPositionGlobal).lengthSquared() > 1.0) && !mOnPositionChanged.empty())
-    {   // If the position has changed my more than 1 meter since the last time we triggered.
-        // filters out some noise. 
-        mLastTestGlobal = mPositionGlobal;
-        mOnPositionChanged(mFrameAgent.getOrigin(), mPositionGlobal);
-    }
-}
-
-//-----------------------------------------------------------------------------
-// getPositionGlobal()
-//-----------------------------------------------------------------------------
-const LLVector3d &LLAgent::getPositionGlobal() const
-{
-	if (isAgentAvatarValid() && !gAgentAvatarp->mDrawable.isNull())
-	{
-		mPositionGlobal = getPosGlobalFromAgent(gAgentAvatarp->getRenderPosition());
-	}
-	else
-	{
-		mPositionGlobal = getPosGlobalFromAgent(mFrameAgent.getOrigin());
-	}
-
-	return mPositionGlobal;
-}
-
-//-----------------------------------------------------------------------------
-// getPositionAgent()
-//-----------------------------------------------------------------------------
-const LLVector3 &LLAgent::getPositionAgent()
-{
-	if (isAgentAvatarValid())
-	{
-		if(gAgentAvatarp->mDrawable.isNull())
-		{
-			mFrameAgent.setOrigin(gAgentAvatarp->getPositionAgent());
-		}
-		else
-	{
-		mFrameAgent.setOrigin(gAgentAvatarp->getRenderPosition());	
-	}
-	}
-
-
-	return mFrameAgent.getOrigin();
-}
-
-boost::signals2::connection LLAgent::whenPositionChanged(position_signal_t::slot_type fn)
-{
-    return mOnPositionChanged.connect(fn);
-}
-
-
-//-----------------------------------------------------------------------------
-// getRegionsVisited()
-//-----------------------------------------------------------------------------
-S32 LLAgent::getRegionsVisited() const
-{
-	return mRegionsVisited.size();
-}
-
-//-----------------------------------------------------------------------------
-// getDistanceTraveled()
-//-----------------------------------------------------------------------------
-F64 LLAgent::getDistanceTraveled() const
-{
-	return mDistanceTraveled;
-}
-
-
-//-----------------------------------------------------------------------------
-// getPosAgentFromGlobal()
-//-----------------------------------------------------------------------------
-LLVector3 LLAgent::getPosAgentFromGlobal(const LLVector3d &pos_global) const
-{
-	LLVector3 pos_agent;
-	pos_agent.setVec(pos_global - mAgentOriginGlobal);
-	return pos_agent;
-}
-
-
-//-----------------------------------------------------------------------------
-// getPosGlobalFromAgent()
-//-----------------------------------------------------------------------------
-LLVector3d LLAgent::getPosGlobalFromAgent(const LLVector3 &pos_agent) const
-{
-	LLVector3d pos_agent_d;
-	pos_agent_d.setVec(pos_agent);
-	return pos_agent_d + mAgentOriginGlobal;
-}
-
-void LLAgent::sitDown()
-{
-	setControlFlags(AGENT_CONTROL_SIT_ON_GROUND);
-}
-
-
-//-----------------------------------------------------------------------------
-// resetAxes()
-//-----------------------------------------------------------------------------
-void LLAgent::resetAxes()
-{
-	mFrameAgent.resetAxes();
-}
-
-
-// Copied from LLCamera::setOriginAndLookAt
-// Look_at must be unit vector
-//-----------------------------------------------------------------------------
-// resetAxes()
-//-----------------------------------------------------------------------------
-void LLAgent::resetAxes(const LLVector3 &look_at)
-{
-	LLVector3	skyward = getReferenceUpVector();
-
-	// if look_at has zero length, fail
-	// if look_at and skyward are parallel, fail
-	//
-	// Test both of these conditions with a cross product.
-	LLVector3 cross(look_at % skyward);
-	if (cross.isNull())
-	{
-		LL_INFOS() << "LLAgent::resetAxes cross-product is zero" << LL_ENDL;
-		return;
-	}
-
-	// Make sure look_at and skyward are not parallel
-	// and neither are zero length
-	LLVector3 left(skyward % look_at);
-	LLVector3 up(look_at % left);
-
-	mFrameAgent.setAxes(look_at, left, up);
-}
-
-
-//-----------------------------------------------------------------------------
-// rotate()
-//-----------------------------------------------------------------------------
-void LLAgent::rotate(F32 angle, const LLVector3 &axis) 
-{ 
-	mFrameAgent.rotate(angle, axis); 
-}
-
-
-//-----------------------------------------------------------------------------
-// rotate()
-//-----------------------------------------------------------------------------
-void LLAgent::rotate(F32 angle, F32 x, F32 y, F32 z) 
-{ 
-	mFrameAgent.rotate(angle, x, y, z); 
-}
-
-
-//-----------------------------------------------------------------------------
-// rotate()
-//-----------------------------------------------------------------------------
-void LLAgent::rotate(const LLMatrix3 &matrix) 
-{ 
-	mFrameAgent.rotate(matrix); 
-}
-
-
-//-----------------------------------------------------------------------------
-// rotate()
-//-----------------------------------------------------------------------------
-void LLAgent::rotate(const LLQuaternion &quaternion) 
-{ 
-	mFrameAgent.rotate(quaternion); 
-}
-
-
-//-----------------------------------------------------------------------------
-// getReferenceUpVector()
-//-----------------------------------------------------------------------------
-LLVector3 LLAgent::getReferenceUpVector()
-{
-	// this vector is in the coordinate frame of the avatar's parent object, or the world if none
-	LLVector3 up_vector = LLVector3::z_axis;
-	if (isAgentAvatarValid() && 
-		gAgentAvatarp->getParent() &&
-		gAgentAvatarp->mDrawable.notNull())
-	{
-		U32 camera_mode = gAgentCamera.getCameraAnimating() ? gAgentCamera.getLastCameraMode() : gAgentCamera.getCameraMode();
-		// and in third person...
-		if (camera_mode == CAMERA_MODE_THIRD_PERSON)
-		{
-			// make the up vector point to the absolute +z axis
-			up_vector = up_vector * ~((LLViewerObject*)gAgentAvatarp->getParent())->getRenderRotation();
-		}
-		else if (camera_mode == CAMERA_MODE_MOUSELOOK)
-		{
-			// make the up vector point to the avatar's +z axis
-			up_vector = up_vector * gAgentAvatarp->mDrawable->getRotation();
-		}
-	}
-
-	return up_vector;
-}
-
-
-// Radians, positive is forward into ground
-//-----------------------------------------------------------------------------
-// pitch()
-//-----------------------------------------------------------------------------
-void LLAgent::pitch(F32 angle)
-{
-	// don't let user pitch if pointed almost all the way down or up
-
-	// A dot B = mag(A) * mag(B) * cos(angle between A and B)
-	// so... cos(angle between A and B) = A dot B / mag(A) / mag(B)
-	//                                  = A dot B for unit vectors
-
-	LLVector3 skyward = getReferenceUpVector();
-
-	// clamp pitch to limits
-	if (angle >= 0.f)
-	{
-		const F32 look_down_limit = 179.f * DEG_TO_RAD;
-		F32 angle_from_skyward = acos(mFrameAgent.getAtAxis() * skyward);
-		if (angle_from_skyward + angle > look_down_limit)
-		{
-			angle = look_down_limit - angle_from_skyward;
-		}
-	}
-	else if (angle < 0.f)
-	{
-		const F32 look_up_limit = 5.f * DEG_TO_RAD;
-		const LLVector3& viewer_camera_pos = LLViewerCamera::getInstance()->getOrigin();
-		LLVector3 agent_focus_pos = getPosAgentFromGlobal(gAgentCamera.calcFocusPositionTargetGlobal());
-		LLVector3 look_dir = agent_focus_pos - viewer_camera_pos;
-		F32 angle_from_skyward = angle_between(look_dir, skyward);
-		if (angle_from_skyward + angle < look_up_limit)
-		{
-			angle = look_up_limit - angle_from_skyward;
-		}
-	}
-
-	if (fabs(angle) > 1e-4)
-	{
-		mFrameAgent.pitch(angle);
-	}
-}
-
-
-//-----------------------------------------------------------------------------
-// roll()
-//-----------------------------------------------------------------------------
-void LLAgent::roll(F32 angle)
-{
-	mFrameAgent.roll(angle);
-}
-
-
-//-----------------------------------------------------------------------------
-// yaw()
-//-----------------------------------------------------------------------------
-void LLAgent::yaw(F32 angle)
-{
-	if (!rotateGrabbed())
-	{
-		mFrameAgent.rotate(angle, getReferenceUpVector());
-	}
-}
-
-
-// Returns a quat that represents the rotation of the agent in the absolute frame
-//-----------------------------------------------------------------------------
-// getQuat()
-//-----------------------------------------------------------------------------
-LLQuaternion LLAgent::getQuat() const
-{
-	return mFrameAgent.getQuaternion();
-}
-
-//-----------------------------------------------------------------------------
-// getControlFlags()
-//-----------------------------------------------------------------------------
-U32 LLAgent::getControlFlags()
-{
-	return mControlFlags;
-}
-
-//-----------------------------------------------------------------------------
-// setControlFlags()
-//-----------------------------------------------------------------------------
-void LLAgent::setControlFlags(U32 mask)
-{
-	mControlFlags |= mask;
-	mbFlagsDirty = true;
-}
-
-
-//-----------------------------------------------------------------------------
-// clearControlFlags()
-//-----------------------------------------------------------------------------
-void LLAgent::clearControlFlags(U32 mask)
-{
-	U32 old_flags = mControlFlags;
-	mControlFlags &= ~mask;
-	if (old_flags != mControlFlags)
-	{
-		mbFlagsDirty = true;
-	}
-}
-
-//-----------------------------------------------------------------------------
-// controlFlagsDirty()
-//-----------------------------------------------------------------------------
-bool LLAgent::controlFlagsDirty() const
-{
-	return mbFlagsDirty;
-}
-
-//-----------------------------------------------------------------------------
-// enableControlFlagReset()
-//-----------------------------------------------------------------------------
-void LLAgent::enableControlFlagReset()
-{
-	mbFlagsNeedReset = true;
-}
-
-//-----------------------------------------------------------------------------
-// resetControlFlags()
-//-----------------------------------------------------------------------------
-void LLAgent::resetControlFlags()
-{
-	if (mbFlagsNeedReset)
-	{
-		mbFlagsNeedReset = false;
-		mbFlagsDirty = false;
-		// reset all of the ephemeral flags
-		// some flags are managed elsewhere
-		mControlFlags &= AGENT_CONTROL_AWAY | AGENT_CONTROL_FLY | AGENT_CONTROL_MOUSELOOK;
-	}
-}
-
-//-----------------------------------------------------------------------------
-// setAFK()
-//-----------------------------------------------------------------------------
-void LLAgent::setAFK()
-{
-	if (gNonInteractive || !gAgent.getRegion())
-	{
-		// Don't set AFK if we're not talking to a region yet.
-		return;
-	}
-
-	if (!(mControlFlags & AGENT_CONTROL_AWAY))
-	{
-		sendAnimationRequest(ANIM_AGENT_AWAY, ANIM_REQUEST_START);
-		setControlFlags(AGENT_CONTROL_AWAY | AGENT_CONTROL_STOP);
-		gAwayTimer.start();
-	}
-}
-
-//-----------------------------------------------------------------------------
-// clearAFK()
-//-----------------------------------------------------------------------------
-void LLAgent::clearAFK()
-{
-	gAwayTriggerTimer.reset();
-
-	// Gods can sometimes get into away state (via gestures)
-	// without setting the appropriate control flag. JC
-	if (mControlFlags & AGENT_CONTROL_AWAY
-		|| (isAgentAvatarValid()
-			&& (gAgentAvatarp->mSignaledAnimations.find(ANIM_AGENT_AWAY) != gAgentAvatarp->mSignaledAnimations.end())))
-	{
-		sendAnimationRequest(ANIM_AGENT_AWAY, ANIM_REQUEST_STOP);
-		clearControlFlags(AGENT_CONTROL_AWAY);
-	}
-}
-
-//-----------------------------------------------------------------------------
-// getAFK()
-//-----------------------------------------------------------------------------
-bool LLAgent::getAFK() const
-{
-	return (mControlFlags & AGENT_CONTROL_AWAY) != 0;
-}
-
-//-----------------------------------------------------------------------------
-// setDoNotDisturb()
-//-----------------------------------------------------------------------------
-void LLAgent::setDoNotDisturb(bool pIsDoNotDisturb)
-{
-	bool isDoNotDisturbSwitchedOff = (mIsDoNotDisturb && !pIsDoNotDisturb);
-	mIsDoNotDisturb = pIsDoNotDisturb;
-	sendAnimationRequest(ANIM_AGENT_DO_NOT_DISTURB, (pIsDoNotDisturb ? ANIM_REQUEST_START : ANIM_REQUEST_STOP));
-	LLNotificationsUI::LLChannelManager::getInstance()->muteAllChannels(pIsDoNotDisturb);
-	if (isDoNotDisturbSwitchedOff)
-	{
-		LLDoNotDisturbNotificationStorage::getInstance()->updateNotifications();
-	}
-	gIMMgr->updateDNDMessageStatus();
-}
-
-//-----------------------------------------------------------------------------
-// isDoNotDisturb()
-//-----------------------------------------------------------------------------
-bool LLAgent::isDoNotDisturb() const
-{
-	return mIsDoNotDisturb;
-}
-
-
-//-----------------------------------------------------------------------------
-// startAutoPilotGlobal()
-//-----------------------------------------------------------------------------
-void LLAgent::startAutoPilotGlobal(
-	const LLVector3d &target_global,
-	const std::string& behavior_name,
-	const LLQuaternion *target_rotation,
-	void (*finish_callback)(bool, void *),
-	void *callback_data,
-	F32 stop_distance,
-	F32 rot_threshold,
-	bool allow_flying)
-{
-	if (!isAgentAvatarValid())
-	{
-		return;
-	}
-
-    if (target_global.isExactlyZero())
-    {
-        LL_WARNS() << "Canceling attempt to start autopilot towards invalid position" << LL_ENDL;
-        return;
-    }
-	
-	// Are there any pending callbacks from previous auto pilot requests?
-	if (mAutoPilotFinishedCallback)
-	{
-		mAutoPilotFinishedCallback(dist_vec(gAgent.getPositionGlobal(), mAutoPilotTargetGlobal) < mAutoPilotStopDistance, mAutoPilotCallbackData);
-	}
-
-	mAutoPilotFinishedCallback = finish_callback;
-	mAutoPilotCallbackData = callback_data;
-	mAutoPilotRotationThreshold = rot_threshold;
-	mAutoPilotBehaviorName = behavior_name;
-	mAutoPilotAllowFlying = allow_flying;
-
-	LLVector3d delta_pos( target_global );
-	delta_pos -= getPositionGlobal();
-	F64 distance = delta_pos.magVec();
-	LLVector3d trace_target = target_global;
-
-	trace_target.mdV[VZ] -= 10.f;
-
-	LLVector3d intersection;
-	LLVector3 normal;
-	LLViewerObject *hit_obj;
-	F32 heightDelta = LLWorld::getInstance()->resolveStepHeightGlobal(NULL, target_global, trace_target, intersection, normal, &hit_obj);
-
-	if (stop_distance > 0.f)
-	{
-		mAutoPilotStopDistance = stop_distance;
-	}
-	else
-	{
-		// Guess at a reasonable stop distance.
-		mAutoPilotStopDistance = (F32) sqrt( distance );
-		if (mAutoPilotStopDistance < 0.5f) 
-		{
-			mAutoPilotStopDistance = 0.5f;
-		}
-	}
-
-	if (mAutoPilotAllowFlying)
-	{
-		mAutoPilotFlyOnStop = getFlying();
-	}
-	else
-	{
-		mAutoPilotFlyOnStop = false;
-	}
-
-	if (distance > 30.0 && mAutoPilotAllowFlying)
-	{
-		setFlying(true);
-	}
-
-	if ( distance > 1.f && 
-		mAutoPilotAllowFlying &&
-		heightDelta > (sqrtf(mAutoPilotStopDistance) + 1.f))
-	{
-		setFlying(true);
-		// Do not force flying for "Sit" behavior to prevent flying after pressing "Stand"
-		// from an object. See EXT-1655.
-		if ("Sit" != mAutoPilotBehaviorName)
-			mAutoPilotFlyOnStop = true;
-	}
-
-	mAutoPilot = true;
-	setAutoPilotTargetGlobal(target_global);
-
-	if (target_rotation)
-	{
-		mAutoPilotUseRotation = true;
-		mAutoPilotTargetFacing = LLVector3::x_axis * *target_rotation;
-		mAutoPilotTargetFacing.mV[VZ] = 0.f;
-		mAutoPilotTargetFacing.normalize();
-	}
-	else
-	{
-		mAutoPilotUseRotation = false;
-	}
-
-	mAutoPilotNoProgressFrameCount = 0;
-}
-
-
-//-----------------------------------------------------------------------------
-// setAutoPilotTargetGlobal
-//-----------------------------------------------------------------------------
-void LLAgent::setAutoPilotTargetGlobal(const LLVector3d &target_global)
-{
-	if (mAutoPilot)
-	{
-		mAutoPilotTargetGlobal = target_global;
-
-		// trace ray down to find height of destination from ground
-		LLVector3d traceEndPt = target_global;
-		traceEndPt.mdV[VZ] -= 20.f;
-
-		LLVector3d targetOnGround;
-		LLVector3 groundNorm;
-		LLViewerObject *obj;
-
-		LLWorld::getInstance()->resolveStepHeightGlobal(NULL, target_global, traceEndPt, targetOnGround, groundNorm, &obj);
-		// Note: this might malfunction for sitting agent, since pelvis stays same, but agent's position becomes lower
-		// But for autopilot to work we assume that agent is standing and ready to go.
-		F64 target_height = llmax((F64)gAgentAvatarp->getPelvisToFoot(), target_global.mdV[VZ] - targetOnGround.mdV[VZ]);
-
-		// clamp z value of target to minimum height above ground
-		mAutoPilotTargetGlobal.mdV[VZ] = targetOnGround.mdV[VZ] + target_height;
-		mAutoPilotTargetDist = (F32)dist_vec(gAgent.getPositionGlobal(), mAutoPilotTargetGlobal);
-	}
-}
-
-//-----------------------------------------------------------------------------
-// startFollowPilot()
-//-----------------------------------------------------------------------------
-void LLAgent::startFollowPilot(const LLUUID &leader_id, bool allow_flying, F32 stop_distance)
-{
-	mLeaderID = leader_id;
-	if ( mLeaderID.isNull() ) return;
-
-	LLViewerObject* object = gObjectList.findObject(mLeaderID);
-	if (!object) 
-	{
-		mLeaderID = LLUUID::null;
-		return;
-	}
-
-	startAutoPilotGlobal(object->getPositionGlobal(), 
-						 std::string(),	// behavior_name
-						 NULL,			// target_rotation
-						 NULL,			// finish_callback
-						 NULL,			// callback_data
-						 stop_distance,
-						 0.03f,			// rotation_threshold
-						 allow_flying);
-}
-
-
-//-----------------------------------------------------------------------------
-// stopAutoPilot()
-//-----------------------------------------------------------------------------
-void LLAgent::stopAutoPilot(bool user_cancel)
-{
-	if (mAutoPilot)
-	{
-		mAutoPilot = false;
-		if (mAutoPilotUseRotation && !user_cancel)
-		{
-			resetAxes(mAutoPilotTargetFacing);
-		}
-		// Restore previous flying state before invoking mAutoPilotFinishedCallback to allow
-		// callback function to change the flying state (like in near_sit_down_point()).
-		// If the user cancelled, don't change the fly state
-		if (!user_cancel)
-		{
-			setFlying(mAutoPilotFlyOnStop);
-		}
-		//NB: auto pilot can terminate for a reason other than reaching the destination
-		if (mAutoPilotFinishedCallback)
-		{
-			mAutoPilotFinishedCallback(!user_cancel && dist_vec(gAgent.getPositionGlobal(), mAutoPilotTargetGlobal) < mAutoPilotStopDistance, mAutoPilotCallbackData);
-			mAutoPilotFinishedCallback = NULL;
-		}
-		mLeaderID = LLUUID::null;
-
-		setControlFlags(AGENT_CONTROL_STOP);
-
-		if (user_cancel && !mAutoPilotBehaviorName.empty())
-		{
-			if (mAutoPilotBehaviorName == "Sit")
-				LL_INFOS("Agent") << "Autopilot-Sit was canceled by user action" << LL_ENDL;
-			else if (mAutoPilotBehaviorName == "Attach")
-				LLNotificationsUtil::add("CancelledAttach");
-			else
-				LLNotificationsUtil::add("Cancelled");
-		}
-	}
-}
-
-
-// Returns necessary agent pitch and yaw changes, radians.
-//-----------------------------------------------------------------------------
-// autoPilot()
-//-----------------------------------------------------------------------------
-void LLAgent::autoPilot(F32 *delta_yaw)
-{
-	if (mAutoPilot)
-	{
-		if (!mLeaderID.isNull())
-		{
-			LLViewerObject* object = gObjectList.findObject(mLeaderID);
-			if (!object) 
-			{
-				stopAutoPilot();
-				return;
-			}
-			mAutoPilotTargetGlobal = object->getPositionGlobal();
-		}
-		
-		if (!isAgentAvatarValid()) return;
-
-		if (gAgentAvatarp->mInAir && mAutoPilotAllowFlying)
-		{
-			setFlying(true);
-		}
-	
-		LLVector3 at;
-		at.setVec(mFrameAgent.getAtAxis());
-		LLVector3 target_agent = getPosAgentFromGlobal(mAutoPilotTargetGlobal);
-		LLVector3 direction = target_agent - getPositionAgent();
-
-		F32 target_dist = direction.magVec();
-
-		if (target_dist >= mAutoPilotTargetDist)
-		{
-			mAutoPilotNoProgressFrameCount++;
-            bool out_of_time = false;
-            if (getFlying())
-            {
-                out_of_time = mAutoPilotNoProgressFrameCount > AUTOPILOT_MAX_TIME_NO_PROGRESS_FLY * gFPSClamped;
-            }
-            else
-            {
-                out_of_time = mAutoPilotNoProgressFrameCount > AUTOPILOT_MAX_TIME_NO_PROGRESS_WALK * gFPSClamped;
-            }
-			if (out_of_time)
-			{
-				stopAutoPilot();
-				return;
-			}
-		}
-
-		mAutoPilotTargetDist = target_dist;
-
-		// Make this a two-dimensional solution
-		at.mV[VZ] = 0.f;
-		direction.mV[VZ] = 0.f;
-
-		at.normalize();
-		F32 xy_distance = direction.normalize();
-
-		F32 yaw = 0.f;
-		if (mAutoPilotTargetDist > mAutoPilotStopDistance)
-		{
-			yaw = angle_between(mFrameAgent.getAtAxis(), direction);
-		}
-		else if (mAutoPilotUseRotation)
-		{
-			// we're close now just aim at target facing
-			yaw = angle_between(at, mAutoPilotTargetFacing);
-			direction = mAutoPilotTargetFacing;
-		}
-
-		yaw = 4.f * yaw / gFPSClamped;
-
-		// figure out which direction to turn
-		LLVector3 scratch(at % direction);
-
-		if (scratch.mV[VZ] > 0.f)
-		{
-			setControlFlags(AGENT_CONTROL_YAW_POS);
-		}
-		else
-		{
-			yaw = -yaw;
-			setControlFlags(AGENT_CONTROL_YAW_NEG);
-		}
-
-		*delta_yaw = yaw;
-
-		// Compute when to start slowing down
-		F32 slow_distance;
-		if (getFlying())
-		{
-			slow_distance = llmax(8.f, mAutoPilotStopDistance + 5.f);
-		}
-		else
-		{
-			slow_distance = llmax(3.f, mAutoPilotStopDistance + 2.f);
-		}
-
-		// If we're flying, handle autopilot points above or below you.
-		if (getFlying() && xy_distance < AUTOPILOT_HEIGHT_ADJUST_DISTANCE)
-		{
-			if (isAgentAvatarValid())
-			{
-				F64 current_height = gAgentAvatarp->getPositionGlobal().mdV[VZ];
-				F32 delta_z = (F32)(mAutoPilotTargetGlobal.mdV[VZ] - current_height);
-				F32 slope = delta_z / xy_distance;
-				if (slope > 0.45f && delta_z > 6.f)
-				{
-					setControlFlags(AGENT_CONTROL_FAST_UP | AGENT_CONTROL_UP_POS);
-				}
-				else if (slope > 0.002f && delta_z > 0.5f)
-				{
-					setControlFlags(AGENT_CONTROL_UP_POS);
-				}
-				else if (slope < -0.45f && delta_z < -6.f && current_height > AUTOPILOT_MIN_TARGET_HEIGHT_OFF_GROUND)
-				{
-					setControlFlags(AGENT_CONTROL_FAST_UP | AGENT_CONTROL_UP_NEG);
-				}
-				else if (slope < -0.002f && delta_z < -0.5f && current_height > AUTOPILOT_MIN_TARGET_HEIGHT_OFF_GROUND)
-				{
-					setControlFlags(AGENT_CONTROL_UP_NEG);
-				}
-			}
-		}
-
-		//  calculate delta rotation to target heading
-		F32 delta_target_heading = angle_between(mFrameAgent.getAtAxis(), mAutoPilotTargetFacing);
-
-		if (xy_distance > slow_distance && yaw < (F_PI / 10.f))
-		{
-			// walking/flying fast
-			setControlFlags(AGENT_CONTROL_FAST_AT | AGENT_CONTROL_AT_POS);
-		}
-		else if (mAutoPilotTargetDist > mAutoPilotStopDistance)
-		{
-            // walking/flying slow
-            U32 movement_flag = 0;
-
-			if (at * direction > 0.9f)
-			{
-                movement_flag = AGENT_CONTROL_AT_POS;
-            }
-            else if (at * direction < -0.9f)
-            {
-                movement_flag = AGENT_CONTROL_AT_NEG;
-            }
-
-            if (getFlying())
-            {
-                // flying is too fast and has high inertia, artificially slow it down
-                // Don't update flags too often, server might not react
-                static U64 last_time_microsec = 0;
-                U64 time_microsec = LLTimer::getTotalTime();
-                U64 delta = time_microsec - last_time_microsec;
-                // fly during ~0-40 ms, stop during ~40-250 ms
-                if (delta > 250000) // 250ms
-                {
-                    // reset even if !movement_flag
-                    last_time_microsec = time_microsec;
-                }
-                else if (delta > 40000) // 40 ms
-                {
-                    clearControlFlags(AGENT_CONTROL_AT_POS | AGENT_CONTROL_AT_POS);
-                    movement_flag = 0;
-                }
-            }
-
-            if (movement_flag)
-            {
-                setControlFlags(movement_flag);
-			}
-		}
-
-		// check to see if we need to keep rotating to target orientation
-		if (mAutoPilotTargetDist < mAutoPilotStopDistance)
-		{
-			setControlFlags(AGENT_CONTROL_STOP);
-			if(!mAutoPilotUseRotation || (delta_target_heading < mAutoPilotRotationThreshold))
-			{
-				stopAutoPilot();
-			}
-		}
-	}
-}
-
-
-//-----------------------------------------------------------------------------
-// propagate()
-//-----------------------------------------------------------------------------
-void LLAgent::propagate(const F32 dt)
-{
-	// Update UI based on agent motion
-	LLFloaterMove *floater_move = LLFloaterReg::findTypedInstance<LLFloaterMove>("moveview");
-	if (floater_move)
-	{
-		floater_move->mForwardButton   ->setToggleState( gAgentCamera.getAtKey() > 0 || gAgentCamera.getWalkKey() > 0 );
-		floater_move->mBackwardButton  ->setToggleState( gAgentCamera.getAtKey() < 0 || gAgentCamera.getWalkKey() < 0 );
-		floater_move->mTurnLeftButton  ->setToggleState( gAgentCamera.getYawKey() > 0.f );
-		floater_move->mTurnRightButton ->setToggleState( gAgentCamera.getYawKey() < 0.f );
-		floater_move->mSlideLeftButton  ->setToggleState( gAgentCamera.getLeftKey() > 0.f );
-		floater_move->mSlideRightButton ->setToggleState( gAgentCamera.getLeftKey() < 0.f );
-		floater_move->mMoveUpButton    ->setToggleState( gAgentCamera.getUpKey() > 0 );
-		floater_move->mMoveDownButton  ->setToggleState( gAgentCamera.getUpKey() < 0 );
-	}
-
-	// handle rotation based on keyboard levels
-	const F32 YAW_RATE = 90.f * DEG_TO_RAD;				// radians per second
-	yaw(YAW_RATE * gAgentCamera.getYawKey() * dt);
-
-	const F32 PITCH_RATE = 90.f * DEG_TO_RAD;			// radians per second
-	pitch(PITCH_RATE * gAgentCamera.getPitchKey() * dt);
-	
-	// handle auto-land behavior
-	if (isAgentAvatarValid())
-	{
-		bool in_air = gAgentAvatarp->mInAir;
-		LLVector3 land_vel = getVelocity();
-		land_vel.mV[VZ] = 0.f;
-
-		if (!in_air 
-			&& gAgentCamera.getUpKey() < 0 
-			&& land_vel.magVecSquared() < MAX_VELOCITY_AUTO_LAND_SQUARED
-			&& gSavedSettings.getBOOL("AutomaticFly"))
-		{
-			// land automatically
-			setFlying(false);
-		}
-	}
-
-	gAgentCamera.clearGeneralKeys();
-}
-
-//-----------------------------------------------------------------------------
-// updateAgentPosition()
-//-----------------------------------------------------------------------------
-void LLAgent::updateAgentPosition(const F32 dt, const F32 yaw_radians, const S32 mouse_x, const S32 mouse_y)
-{
-    static LLCachedControl<F32> hint_timeout(gSavedSettings, "NotMovingHintTimeout");
-	if (mMoveTimer.getStarted() && mMoveTimer.getElapsedTimeF32() > hint_timeout)
-	{
-		LLFirstUse::notMoving();
-	}
-
-	propagate(dt);
-
-	// static S32 cameraUpdateCount = 0;
-
-	rotate(yaw_radians, 0, 0, 1);
-	
-	//
-	// Check for water and land collision, set underwater flag
-	//
-
-	gAgentCamera.updateLookAt(mouse_x, mouse_y);
-
-    // When agent has no parents, position updates come from setPositionAgent()
-    // But when agent has a parent (ex: is seated), position remains unchanged
-    // relative to parent and no parent's position update trigger
-    // setPositionAgent().
-    // But EEP's sky track selection still needs an update if agent has a parent
-    // and parent moves (ex: vehicles).
-    if (isAgentAvatarValid()
-        && gAgentAvatarp->getParent()
-        && !mOnPositionChanged.empty()
-        )
-    {
-        LLVector3d new_position = getPositionGlobal();
-        if ((mLastTestGlobal - new_position).lengthSquared() > 1.0)
-        {
-            // If the position has changed by more than 1 meter since the last time we triggered.
-            // filters out some noise. 
-            mLastTestGlobal = new_position;
-            mOnPositionChanged(mFrameAgent.getOrigin(), new_position);
-        }
-    }
-}
-
-// friends and operators
-
-std::ostream& operator<<(std::ostream &s, const LLAgent &agent)
-{
-	// This is unfinished, but might never be used. 
-	// We'll just leave it for now; we can always delete it.
-	s << " { "
-	  << "  Frame = " << agent.mFrameAgent << "\n"
-	  << " }";
-	return s;
-}
-
-// true if your own avatar needs to be rendered.  Usually only
-// in third person and build.
-//-----------------------------------------------------------------------------
-// needsRenderAvatar()
-//-----------------------------------------------------------------------------
-bool LLAgent::needsRenderAvatar()
-{
-	if (gAgentCamera.cameraMouselook() && !LLVOAvatar::sVisibleInFirstPerson)
-	{
-		return false;
-	}
-
-	return mShowAvatar && mOutfitChosen;
-}
-
-// true if we need to render your own avatar's head.
-bool LLAgent::needsRenderHead()
-{
-	return (LLVOAvatar::sVisibleInFirstPerson && LLPipeline::sReflectionRender) || (mShowAvatar && !gAgentCamera.cameraMouselook());
-}
-
-//-----------------------------------------------------------------------------
-// startTyping()
-//-----------------------------------------------------------------------------
-void LLAgent::startTyping()
-{
-	mTypingTimer.reset();
-
-	if (getRenderState() & AGENT_STATE_TYPING)
-	{
-		// already typing, don't trigger a different animation
-		return;
-	}
-	setRenderState(AGENT_STATE_TYPING);
-
-	if (mChatTimer.getElapsedTimeF32() < 2.f)
-	{
-		LLViewerObject* chatter = gObjectList.findObject(mLastChatterID);
-		if (chatter && chatter->isAvatar())
-		{
-			gAgentCamera.setLookAt(LOOKAT_TARGET_RESPOND, chatter, LLVector3::zero);
-		}
-	}
-
-	if (gSavedSettings.getBOOL("PlayTypingAnim"))
-	{
-		sendAnimationRequest(ANIM_AGENT_TYPE, ANIM_REQUEST_START);
-	}
-	(LLFloaterReg::getTypedInstance<LLFloaterIMNearbyChat>("nearby_chat"))->
-			sendChatFromViewer("", CHAT_TYPE_START, false);
-}
-
-//-----------------------------------------------------------------------------
-// stopTyping()
-//-----------------------------------------------------------------------------
-void LLAgent::stopTyping()
-{
-	if (mRenderState & AGENT_STATE_TYPING)
-	{
-		clearRenderState(AGENT_STATE_TYPING);
-		sendAnimationRequest(ANIM_AGENT_TYPE, ANIM_REQUEST_STOP);
-		(LLFloaterReg::getTypedInstance<LLFloaterIMNearbyChat>("nearby_chat"))->
-				sendChatFromViewer("", CHAT_TYPE_STOP, false);
-	}
-}
-
-//-----------------------------------------------------------------------------
-// setRenderState()
-//-----------------------------------------------------------------------------
-void LLAgent::setRenderState(U8 newstate)
-{
-	mRenderState |= newstate;
-}
-
-//-----------------------------------------------------------------------------
-// clearRenderState()
-//-----------------------------------------------------------------------------
-void LLAgent::clearRenderState(U8 clearstate)
-{
-	mRenderState &= ~clearstate;
-}
-
-
-//-----------------------------------------------------------------------------
-// getRenderState()
-//-----------------------------------------------------------------------------
-U8 LLAgent::getRenderState()
-{
-	// *FIX: don't do stuff in a getter!  This is infinite loop city!
-	if ((mTypingTimer.getElapsedTimeF32() > TYPING_TIMEOUT_SECS) 
-		&& (mRenderState & AGENT_STATE_TYPING))
-	{
-		stopTyping();
-	}
-	
-	if ((!LLSelectMgr::getInstance()->getSelection()->isEmpty() && LLSelectMgr::getInstance()->shouldShowSelection())
-		|| LLToolMgr::getInstance()->getCurrentTool()->isEditing() )
-	{
-		setRenderState(AGENT_STATE_EDITING);
-	}
-	else
-	{
-		clearRenderState(AGENT_STATE_EDITING);
-	}
-
-	return mRenderState;
-}
-
-//-----------------------------------------------------------------------------
-//-----------------------------------------------------------------------------
-
-//-----------------------------------------------------------------------------
-// endAnimationUpdateUI()
-//-----------------------------------------------------------------------------
-void LLAgent::endAnimationUpdateUI()
-{
-	if (LLApp::isExiting()
-		|| !gViewerWindow
-		|| !gMenuBarView
-		|| !gToolBarView
-		|| !gStatusBar)
-	{
-		return;
-	}
-	if (gAgentCamera.getCameraMode() == gAgentCamera.getLastCameraMode())
-	{
-		// We're already done endAnimationUpdateUI for this transition.
-		return;
-	}
-
-	// clean up UI from mode we're leaving
-	if (gAgentCamera.getLastCameraMode() == CAMERA_MODE_MOUSELOOK )
-	{
-		gToolBarView->setToolBarsVisible(true);
-		// show mouse cursor
-		gViewerWindow->showCursor();
-		// show menus
-		gMenuBarView->setVisible(true);
-		LLNavigationBar::getInstance()->setVisible(true && gSavedSettings.getBOOL("ShowNavbarNavigationPanel"));
-		gStatusBar->setVisibleForMouselook(true);
-
-        static LLCachedControl<bool> show_mini_location_panel(gSavedSettings, "ShowMiniLocationPanel");
-		if (show_mini_location_panel)
-		{
-			LLPanelTopInfoBar::getInstance()->setVisible(true);
-		}
-
-		LLChicletBar::getInstance()->setVisible(true);
-
-		LLPanelStandStopFlying::getInstance()->setVisible(true);
-
-		LLToolMgr::getInstance()->setCurrentToolset(gBasicToolset);
-
-		LLFloaterCamera::onLeavingMouseLook();
-
-		if (mMouselookModeOutSignal)
-		{
-			(*mMouselookModeOutSignal)();
-		}
-
-		// Only pop if we have pushed...
-		if (true == mViewsPushed)
-		{
-#if 0 // Use this once all floaters are registered
-			LLFloaterReg::restoreVisibleInstances();
-#else // Use this for now
-			LLFloaterView::skip_list_t skip_list;
-			if (LLFloaterReg::findInstance("mini_map"))
-			{
-				skip_list.insert(LLFloaterReg::findInstance("mini_map"));
-			}
-			if (LLFloaterReg::findInstance("beacons"))
-			{
-				skip_list.insert(LLFloaterReg::findInstance("beacons"));
-			}
-			LLFloaterIMContainer* im_box = LLFloaterReg::getTypedInstance<LLFloaterIMContainer>("im_container");
-			LLFloaterIMContainer::floater_list_t conversations;
-			im_box->getDetachedConversationFloaters(conversations);
-			for (LLFloater* conversation : conversations)
-			{
-				LL_INFOS() << "skip_list.insert(session_floater): " << conversation->getTitle() << LL_ENDL;
-				skip_list.insert(conversation);
-			}
-
-			gFloaterView->popVisibleAll(skip_list);
-#endif
-			mViewsPushed = false;
-		}
-
-		
-		gAgentCamera.setLookAt(LOOKAT_TARGET_CLEAR);
-		if( gMorphView )
-		{
-			gMorphView->setVisible( false );
-		}
-
-		// Disable mouselook-specific animations
-		if (isAgentAvatarValid())
-		{
-			if( gAgentAvatarp->isAnyAnimationSignaled(AGENT_GUN_AIM_ANIMS, NUM_AGENT_GUN_AIM_ANIMS) )
-			{
-				if (gAgentAvatarp->mSignaledAnimations.find(ANIM_AGENT_AIM_RIFLE_R) != gAgentAvatarp->mSignaledAnimations.end())
-				{
-					sendAnimationRequest(ANIM_AGENT_AIM_RIFLE_R, ANIM_REQUEST_STOP);
-					sendAnimationRequest(ANIM_AGENT_HOLD_RIFLE_R, ANIM_REQUEST_START);
-				}
-				if (gAgentAvatarp->mSignaledAnimations.find(ANIM_AGENT_AIM_HANDGUN_R) != gAgentAvatarp->mSignaledAnimations.end())
-				{
-					sendAnimationRequest(ANIM_AGENT_AIM_HANDGUN_R, ANIM_REQUEST_STOP);
-					sendAnimationRequest(ANIM_AGENT_HOLD_HANDGUN_R, ANIM_REQUEST_START);
-				}
-				if (gAgentAvatarp->mSignaledAnimations.find(ANIM_AGENT_AIM_BAZOOKA_R) != gAgentAvatarp->mSignaledAnimations.end())
-				{
-					sendAnimationRequest(ANIM_AGENT_AIM_BAZOOKA_R, ANIM_REQUEST_STOP);
-					sendAnimationRequest(ANIM_AGENT_HOLD_BAZOOKA_R, ANIM_REQUEST_START);
-				}
-				if (gAgentAvatarp->mSignaledAnimations.find(ANIM_AGENT_AIM_BOW_L) != gAgentAvatarp->mSignaledAnimations.end())
-				{
-					sendAnimationRequest(ANIM_AGENT_AIM_BOW_L, ANIM_REQUEST_STOP);
-					sendAnimationRequest(ANIM_AGENT_HOLD_BOW_L, ANIM_REQUEST_START);
-				}
-			}
-		}
-	}
-	else if (gAgentCamera.getLastCameraMode() == CAMERA_MODE_CUSTOMIZE_AVATAR)
-	{
-		// make sure we ask to save changes
-
-		LLToolMgr::getInstance()->setCurrentToolset(gBasicToolset);
-
-		if( gMorphView )
-		{
-			gMorphView->setVisible( false );
-		}
-
-		if (isAgentAvatarValid())
-		{
-			if(mCustomAnim)
-			{
-				sendAnimationRequest(ANIM_AGENT_CUSTOMIZE, ANIM_REQUEST_STOP);
-				sendAnimationRequest(ANIM_AGENT_CUSTOMIZE_DONE, ANIM_REQUEST_START);
-
-				mCustomAnim = false ;
-			}
-			
-		}
-		gAgentCamera.setLookAt(LOOKAT_TARGET_CLEAR);
-
-		LLFloaterCamera::onAvatarEditingAppearance(false);
-	}
-
-	//---------------------------------------------------------------------
-	// Set up UI for mode we're entering
-	//---------------------------------------------------------------------
-	if (gAgentCamera.getCameraMode() == CAMERA_MODE_MOUSELOOK)
-	{
-		// clean up UI
-		// first show anything hidden by UI toggle
-		gViewerWindow->setUIVisibility(true);
-
-		// then hide stuff we want hidden for mouselook 
-		gToolBarView->setToolBarsVisible(false);
-		gMenuBarView->setVisible(false);
-		LLNavigationBar::getInstance()->setVisible(false);
-		gStatusBar->setVisibleForMouselook(false);
-
-		LLPanelTopInfoBar::getInstance()->setVisible(false);
-
-		LLChicletBar::getInstance()->setVisible(false);
-
-		LLPanelStandStopFlying::getInstance()->setVisible(false);
-
-		// clear out camera lag effect
-		gAgentCamera.clearCameraLag();
-
-		// JC - Added for always chat in third person option
-		gFocusMgr.setKeyboardFocus(NULL);
-
-		LLToolMgr::getInstance()->setCurrentToolset(gMouselookToolset);
-
-		mViewsPushed = true;
-
-		if (mMouselookModeInSignal)
-		{
-			(*mMouselookModeInSignal)();
-		}
-
-		// hide all floaters except the mini map
-
-#if 0 // Use this once all floaters are registered
-		std::set<std::string> exceptions;
-		exceptions.insert("mini_map");
-		LLFloaterReg::hideVisibleInstances(exceptions);
-#else // Use this for now
-		LLFloaterView::skip_list_t skip_list;
-		skip_list.insert(LLFloaterReg::findInstance("mini_map"));
-		skip_list.insert(LLFloaterReg::findInstance("beacons"));
-		gFloaterView->pushVisibleAll(false, skip_list);
-#endif
-
-		if( gMorphView )
-		{
-			gMorphView->setVisible(false);
-		}
-
-		gConsole->setVisible( true );
-
-		if (isAgentAvatarValid())
-		{
-			// Trigger mouselook-specific animations
-			if( gAgentAvatarp->isAnyAnimationSignaled(AGENT_GUN_HOLD_ANIMS, NUM_AGENT_GUN_HOLD_ANIMS) )
-			{
-				if (gAgentAvatarp->mSignaledAnimations.find(ANIM_AGENT_HOLD_RIFLE_R) != gAgentAvatarp->mSignaledAnimations.end())
-				{
-					sendAnimationRequest(ANIM_AGENT_HOLD_RIFLE_R, ANIM_REQUEST_STOP);
-					sendAnimationRequest(ANIM_AGENT_AIM_RIFLE_R, ANIM_REQUEST_START);
-				}
-				if (gAgentAvatarp->mSignaledAnimations.find(ANIM_AGENT_HOLD_HANDGUN_R) != gAgentAvatarp->mSignaledAnimations.end())
-				{
-					sendAnimationRequest(ANIM_AGENT_HOLD_HANDGUN_R, ANIM_REQUEST_STOP);
-					sendAnimationRequest(ANIM_AGENT_AIM_HANDGUN_R, ANIM_REQUEST_START);
-				}
-				if (gAgentAvatarp->mSignaledAnimations.find(ANIM_AGENT_HOLD_BAZOOKA_R) != gAgentAvatarp->mSignaledAnimations.end())
-				{
-					sendAnimationRequest(ANIM_AGENT_HOLD_BAZOOKA_R, ANIM_REQUEST_STOP);
-					sendAnimationRequest(ANIM_AGENT_AIM_BAZOOKA_R, ANIM_REQUEST_START);
-				}
-				if (gAgentAvatarp->mSignaledAnimations.find(ANIM_AGENT_HOLD_BOW_L) != gAgentAvatarp->mSignaledAnimations.end())
-				{
-					sendAnimationRequest(ANIM_AGENT_HOLD_BOW_L, ANIM_REQUEST_STOP);
-					sendAnimationRequest(ANIM_AGENT_AIM_BOW_L, ANIM_REQUEST_START);
-				}
-			}
-			if (gAgentAvatarp->getParent())
-			{
-				LLVector3 at_axis = LLViewerCamera::getInstance()->getAtAxis();
-				LLViewerObject* root_object = (LLViewerObject*)gAgentAvatarp->getRoot();
-				if (root_object->flagCameraDecoupled())
-				{
-					resetAxes(at_axis);
-				}
-				else
-				{
-					resetAxes(at_axis * ~((LLViewerObject*)gAgentAvatarp->getParent())->getRenderRotation());
-				}
-			}
-		}
-	}
-	else if (gAgentCamera.getCameraMode() == CAMERA_MODE_CUSTOMIZE_AVATAR)
-	{
-		LLToolMgr::getInstance()->setCurrentToolset(gFaceEditToolset);
-
-		if( gMorphView )
-		{
-			gMorphView->setVisible( true );
-		}
-
-		// freeze avatar
-		if (isAgentAvatarValid())
-		{
-			mPauseRequest = gAgentAvatarp->requestPause();
-		}
-
-		LLFloaterCamera::onAvatarEditingAppearance(true);
-	}
-
-	if (isAgentAvatarValid())
-	{
-		gAgentAvatarp->updateAttachmentVisibility(gAgentCamera.getCameraMode());
-	}
-
-	gFloaterTools->dirty();
-
-	// Don't let this be called more than once if the camera
-	// mode hasn't changed.  --JC
-	gAgentCamera.updateLastCamera();
-}
-
-boost::signals2::connection LLAgent::setMouselookModeInCallback( const camera_signal_t::slot_type& cb )
-{
-	if (!mMouselookModeInSignal) mMouselookModeInSignal = new camera_signal_t();
-	return mMouselookModeInSignal->connect(cb);
-}
-
-boost::signals2::connection LLAgent::setMouselookModeOutCallback( const camera_signal_t::slot_type& cb )
-{
-	if (!mMouselookModeOutSignal) mMouselookModeOutSignal = new camera_signal_t();
-	return mMouselookModeOutSignal->connect(cb);
-}
-
-//-----------------------------------------------------------------------------
-// heardChat()
-//-----------------------------------------------------------------------------
-void LLAgent::heardChat(const LLUUID& id)
-{
-	// log text and voice chat to speaker mgr
-	// for keeping track of active speakers, etc.
-	LLLocalSpeakerMgr::getInstance()->speakerChatted(id);
-
-	// don't respond to your own voice
-	if (id == getID()) return;
-	
-	if (ll_rand(2) == 0) 
-	{
-		LLViewerObject *chatter = gObjectList.findObject(mLastChatterID);
-		gAgentCamera.setLookAt(LOOKAT_TARGET_AUTO_LISTEN, chatter, LLVector3::zero);
-	}			
-
-	mLastChatterID = id;
-	mChatTimer.reset();
-}
-
-LLSD ll_sdmap_from_vector3(const LLVector3& vec)
-{
-    LLSD ret;
-    ret["X"] = vec.mV[VX];
-    ret["Y"] = vec.mV[VY];
-    ret["Z"] = vec.mV[VZ];
-    return ret;
-}
-
-LLVector3 ll_vector3_from_sdmap(const LLSD& sd)
-{
-    LLVector3 ret;
-    ret.mV[VX] = F32(sd["X"].asReal());
-    ret.mV[VY] = F32(sd["Y"].asReal());
-    ret.mV[VZ] = F32(sd["Z"].asReal());
-    return ret;
-}
-
-void LLAgent::setStartPosition( U32 location_id )
-{
-    LLViewerObject          *object;
-
-    if (gAgentID == LLUUID::null)
-    {
-        return;
-    }
-    // we've got an ID for an agent viewerobject
-    object = gObjectList.findObject(gAgentID);
-    if (! object)
-    {
-        LL_INFOS() << "setStartPosition - Can't find agent viewerobject id " << gAgentID << LL_ENDL;
-        return;
-    }
-    // we've got the viewer object
-    // Sometimes the agent can be velocity interpolated off of
-    // this simulator.  Clamp it to the region the agent is
-    // in, a little bit in on each side.
-    const F32 INSET = 0.5f; //meters
-    const F32 REGION_WIDTH = LLWorld::getInstance()->getRegionWidthInMeters();
-
-    LLVector3 agent_pos = getPositionAgent();
-
-    if (isAgentAvatarValid())
-    {
-        // the z height is at the agent's feet
-        agent_pos.mV[VZ] -= 0.5f * (gAgentAvatarp->mBodySize.mV[VZ] + gAgentAvatarp->mAvatarOffset.mV[VZ]);
-    }
-
-    agent_pos.mV[VX] = llclamp( agent_pos.mV[VX], INSET, REGION_WIDTH - INSET );
-    agent_pos.mV[VY] = llclamp( agent_pos.mV[VY], INSET, REGION_WIDTH - INSET );
-
-    // Don't let them go below ground, or too high.
-    agent_pos.mV[VZ] = llclamp( agent_pos.mV[VZ],
-                                mRegionp->getLandHeightRegion( agent_pos ),
-                                LLWorld::getInstance()->getRegionMaxHeight() );
-    // Send the CapReq
-    LLSD request;
-    LLSD body;
-    LLSD homeLocation;
-
-    homeLocation["LocationId"] = LLSD::Integer(location_id);
-    homeLocation["LocationPos"] = ll_sdmap_from_vector3(agent_pos);
-    homeLocation["LocationLookAt"] = ll_sdmap_from_vector3(mFrameAgent.getAtAxis());
-
-    body["HomeLocation"] = homeLocation;
-
-    if (!requestPostCapability("HomeLocation", body, 
-            boost::bind(&LLAgent::setStartPositionSuccess, this, _1)))
-        LL_WARNS() << "Unable to post to HomeLocation capability." << LL_ENDL;
-}
-
-void LLAgent::setStartPositionSuccess(const LLSD &result)
-{
-    LLVector3 agent_pos;
-    bool      error = true;
-
-    do {
-        // was the call to /agent/<agent-id>/home-location successful?
-        // If not, we keep error set to true
-        if (!result.has("success"))
-            break;
-
-        if (0 != strncmp("true", result["success"].asString().c_str(), 4))
-            break;
-
-        // did the simulator return a "justified" home location?
-        // If no, we keep error set to true
-        if (!result.has("HomeLocation"))
-            break;
-
-        if ((!result["HomeLocation"].has("LocationPos")) ||
-                (!result["HomeLocation"]["LocationPos"].has("X")) ||
-                (!result["HomeLocation"]["LocationPos"].has("Y")) ||
-                (!result["HomeLocation"]["LocationPos"].has("Z")))
-            break;
-
-        agent_pos.mV[VX] = result["HomeLocation"]["LocationPos"]["X"].asInteger();
-        agent_pos.mV[VY] = result["HomeLocation"]["LocationPos"]["Y"].asInteger();
-        agent_pos.mV[VZ] = result["HomeLocation"]["LocationPos"]["Z"].asInteger();
-
-        error = false;
-
-    } while (0);
-
-    if (error)
-    {
-        LL_WARNS() << "Error in response to home position set." << LL_ENDL;
-    }
-    else
-    {
-        LL_INFOS() << "setting home position" << LL_ENDL;
-
-        LLViewerRegion *viewer_region = gAgent.getRegion();
-        setHomePosRegion(viewer_region->getHandle(), agent_pos);
-    }
-}
-
-void LLAgent::requestStopMotion( LLMotion* motion )
-{
-	// Notify all avatars that a motion has stopped.
-	// This is needed to clear the animation state bits
-	LLUUID anim_state = motion->getID();
-	onAnimStop(motion->getID());
-
-	// if motion is not looping, it could have stopped by running out of time
-	// so we need to tell the server this
-//	LL_INFOS() << "Sending stop for motion " << motion->getName() << LL_ENDL;
-	sendAnimationRequest( anim_state, ANIM_REQUEST_STOP );
-}
-
-void LLAgent::onAnimStop(const LLUUID& id)
-{
-	// handle automatic state transitions (based on completion of animation playback)
-	if (id == ANIM_AGENT_STAND)
-	{
-		stopFidget();
-	}
-	else if (id == ANIM_AGENT_AWAY)
-	{
-		clearAFK();
-	}
-	else if (id == ANIM_AGENT_STANDUP)
-	{
-		// send stand up command
-		setControlFlags(AGENT_CONTROL_FINISH_ANIM);
-
-		// now trigger dusting self off animation
-		if (isAgentAvatarValid() && !gAgentAvatarp->mBelowWater && rand() % 3 == 0)
-			sendAnimationRequest( ANIM_AGENT_BRUSH, ANIM_REQUEST_START );
-	}
-	else if (id == ANIM_AGENT_PRE_JUMP || id == ANIM_AGENT_LAND || id == ANIM_AGENT_MEDIUM_LAND)
-	{
-		setControlFlags(AGENT_CONTROL_FINISH_ANIM);
-	}
-}
-
-bool LLAgent::isGodlike() const
-{
-	return mAgentAccess->isGodlike();
-}
-
-bool LLAgent::isGodlikeWithoutAdminMenuFakery() const
-{
-	return mAgentAccess->isGodlikeWithoutAdminMenuFakery();
-}
-
-U8 LLAgent::getGodLevel() const
-{
-	return mAgentAccess->getGodLevel();
-}
-
-bool LLAgent::wantsPGOnly() const
-{
-	return mAgentAccess->wantsPGOnly();
-}
-
-bool LLAgent::canAccessMature() const
-{
-	return mAgentAccess->canAccessMature();
-}
-
-bool LLAgent::canAccessAdult() const
-{
-	return mAgentAccess->canAccessAdult();
-}
-
-bool LLAgent::canAccessMaturityInRegion( U64 region_handle ) const
-{
-	LLViewerRegion *regionp = LLWorld::getInstance()->getRegionFromHandle( region_handle );
-	if( regionp )
-	{
-		switch( regionp->getSimAccess() )
-		{
-			case SIM_ACCESS_MATURE:
-				if( !canAccessMature() )
-					return false;
-				break;
-			case SIM_ACCESS_ADULT:
-				if( !canAccessAdult() )
-					return false;
-				break;
-			default:
-				// Oh, go on and hear the silly noises.
-				break;
-		}
-	}
-	
-	return true;
-}
-
-bool LLAgent::canAccessMaturityAtGlobal( LLVector3d pos_global ) const
-{
-	U64 region_handle = to_region_handle_global( pos_global.mdV[0], pos_global.mdV[1] );
-	return canAccessMaturityInRegion( region_handle );
-}
-
-bool LLAgent::prefersPG() const
-{
-	return mAgentAccess->prefersPG();
-}
-
-bool LLAgent::prefersMature() const
-{
-	return mAgentAccess->prefersMature();
-}
-	
-bool LLAgent::prefersAdult() const
-{
-	return mAgentAccess->prefersAdult();
-}
-
-bool LLAgent::isTeen() const
-{
-	return mAgentAccess->isTeen();
-}
-
-bool LLAgent::isMature() const
-{
-	return mAgentAccess->isMature();
-}
-
-bool LLAgent::isAdult() const
-{
-	return mAgentAccess->isAdult();
-}
-
-//static 
-int LLAgent::convertTextToMaturity(char text)
-{
-	return LLAgentAccess::convertTextToMaturity(text);
-}
-
-void LLAgent::handlePreferredMaturityResult(U8 pServerMaturity)
-{
-	// Update the number of responses received
-	++mMaturityPreferenceResponseId;
-	llassert(mMaturityPreferenceResponseId <= mMaturityPreferenceRequestId);
-
-	// Update the last known server maturity response
-	mLastKnownResponseMaturity = pServerMaturity;
-
-	// Ignore all responses if we know there are more unanswered requests that are expected
-	if (mMaturityPreferenceResponseId == mMaturityPreferenceRequestId)
-	{
-		// If we received a response that matches the last known request, then we are good
-		if (mLastKnownRequestMaturity == mLastKnownResponseMaturity)
-		{
-			mMaturityPreferenceNumRetries = 0;
-			reportPreferredMaturitySuccess();
-			llassert(static_cast<U8>(gSavedSettings.getU32("PreferredMaturity")) == mLastKnownResponseMaturity);
-		}
-		// Else, the viewer is out of sync with the server, so let's try to re-sync with the
-		// server by re-sending our last known request.  Cap the re-tries at 3 just to be safe.
-		else if (++mMaturityPreferenceNumRetries <= 3)
-		{
-			LL_INFOS() << "Retrying attempt #" << mMaturityPreferenceNumRetries << " to set viewer preferred maturity to '"
-				<< LLViewerRegion::accessToString(mLastKnownRequestMaturity) << "'" << LL_ENDL;
-			sendMaturityPreferenceToServer(mLastKnownRequestMaturity);
-		}
-		// Else, the viewer is style out of sync with the server after 3 retries, so inform the user
-		else
-		{
-			mMaturityPreferenceNumRetries = 0;
-			LL_WARNS() << "Too many retries for maturity preference" << LL_ENDL;
-			reportPreferredMaturityError();
-		}
-	}
-}
-
-void LLAgent::handlePreferredMaturityError()
-{
-	// Update the number of responses received
-	++mMaturityPreferenceResponseId;
-	llassert(mMaturityPreferenceResponseId <= mMaturityPreferenceRequestId);
-
-	// Ignore all responses if we know there are more unanswered requests that are expected
-	if (mMaturityPreferenceResponseId == mMaturityPreferenceRequestId)
-	{
-		mMaturityPreferenceNumRetries = 0;
-
-		// If we received a response that matches the last known request, then we are synced with
-		// the server, but not quite sure why we are
-		if (mLastKnownRequestMaturity == mLastKnownResponseMaturity)
-		{
-			LL_WARNS() << "Got an error but maturity preference '" << LLViewerRegion::accessToString(mLastKnownRequestMaturity)
-				<< "' seems to be in sync with the server" << LL_ENDL;
-			reportPreferredMaturitySuccess();
-		}
-		// Else, the more likely case is that the last request does not match the last response,
-		// so inform the user
-		else
-		{
-			reportPreferredMaturityError();
-		}
-	}
-}
-
-void LLAgent::reportPreferredMaturitySuccess()
-{
-	// If there is a pending teleport request waiting for the maturity preference to be synced with
-	// the server, let's start the pending request
-	if (hasPendingTeleportRequest())
-	{
-		startTeleportRequest();
-	}
-}
-
-void LLAgent::reportPreferredMaturityError()
-{
-	// If there is a pending teleport request waiting for the maturity preference to be synced with
-	// the server, we were unable to successfully sync with the server on maturity preference, so let's
-	// just raise the screen.
-	mIsMaturityRatingChangingDuringTeleport = false;
-	if (hasPendingTeleportRequest())
-	{
-		LL_WARNS("Teleport") << "Teleport failing due to preferred maturity error" << LL_ENDL;
-		setTeleportState(LLAgent::TELEPORT_NONE);
-	}
-
-	// Get the last known maturity request from the user activity
-	std::string preferredMaturity = LLViewerRegion::accessToString(mLastKnownRequestMaturity);
-	LLStringUtil::toLower(preferredMaturity);
-
-	// Get the last known maturity response from the server
-	std::string actualMaturity = LLViewerRegion::accessToString(mLastKnownResponseMaturity);
-	LLStringUtil::toLower(actualMaturity);
-
-	// Notify the user
-	LLSD args = LLSD::emptyMap();
-	args["PREFERRED_MATURITY"] = preferredMaturity;
-	args["ACTUAL_MATURITY"] = actualMaturity;
-	LLNotificationsUtil::add("MaturityChangeError", args);
-
-	// Check the saved settings to ensure that we are consistent.  If we are not consistent, update
-	// the viewer, but do not send anything to server
-	U8 localMaturity = static_cast<U8>(gSavedSettings.getU32("PreferredMaturity"));
-	if (localMaturity != mLastKnownResponseMaturity)
-	{
-		bool tmpIsDoSendMaturityPreferenceToServer = mIsDoSendMaturityPreferenceToServer;
-		mIsDoSendMaturityPreferenceToServer = false;
-		LL_INFOS() << "Setting viewer preferred maturity to '" << LLViewerRegion::accessToString(mLastKnownResponseMaturity) << "'" << LL_ENDL;
-		gSavedSettings.setU32("PreferredMaturity", static_cast<U32>(mLastKnownResponseMaturity));
-		mIsDoSendMaturityPreferenceToServer = tmpIsDoSendMaturityPreferenceToServer;
-	}
-}
-
-bool LLAgent::isMaturityPreferenceSyncedWithServer() const
-{
-	return (mMaturityPreferenceRequestId == mMaturityPreferenceResponseId);
-}
-
-void LLAgent::sendMaturityPreferenceToServer(U8 pPreferredMaturity)
-{
-	// Only send maturity preference to the server if enabled
-	if (mIsDoSendMaturityPreferenceToServer)
-	{
-		// Increment the number of requests.  The handlers manage a separate count of responses.
-		++mMaturityPreferenceRequestId;
-
-		// Update the last know maturity request
-		mLastKnownRequestMaturity = pPreferredMaturity;
-
-		// If we don't have a region, report it as an error
-		if (getRegion() == NULL)
-		{
-			LL_WARNS("Agent") << "Region is not defined, can not change Maturity setting." << LL_ENDL;
-			return;
-		}
-
-		LLSD access_prefs = LLSD::emptyMap();
-		access_prefs["max"] = LLViewerRegion::accessToShortString(pPreferredMaturity);
-
-		LLSD postData = LLSD::emptyMap();
-		postData["access_prefs"] = access_prefs;
-		LL_INFOS() << "Sending viewer preferred maturity to '" << LLViewerRegion::accessToString(pPreferredMaturity) << LL_ENDL;
-
-        if (!requestPostCapability("UpdateAgentInformation", postData,
-            static_cast<httpCallback_t>(boost::bind(&LLAgent::processMaturityPreferenceFromServer, this, _1, pPreferredMaturity)),
-            static_cast<httpCallback_t>(boost::bind(&LLAgent::handlePreferredMaturityError, this))
-            ))
-        {
-            LL_WARNS("Agent") << "Maturity request post failed." << LL_ENDL;
-        }
-	}
-}
-
-
-void LLAgent::processMaturityPreferenceFromServer(const LLSD &result, U8 perferredMaturity)
-{
-    U8 maturity = SIM_ACCESS_MIN;
-
-    llassert(result.isDefined());
-    llassert(result.isMap());
-    llassert(result.has("access_prefs"));
-    llassert(result.get("access_prefs").isMap());
-    llassert(result.get("access_prefs").has("max"));
-    llassert(result.get("access_prefs").get("max").isString());
-    if (result.isDefined() && result.isMap() && result.has("access_prefs")
-        && result.get("access_prefs").isMap() && result.get("access_prefs").has("max")
-        && result.get("access_prefs").get("max").isString())
-    {
-        LLSD::String actualPreference = result.get("access_prefs").get("max").asString();
-        LLStringUtil::trim(actualPreference);
-        maturity = LLViewerRegion::shortStringToAccess(actualPreference);
-    }
-
-    if (maturity != perferredMaturity)
-    {
-        LL_WARNS() << "while attempting to change maturity preference from '"
-            << LLViewerRegion::accessToString(mLastKnownResponseMaturity)
-            << "' to '" << LLViewerRegion::accessToString(perferredMaturity)
-            << "', the server responded with '"
-            << LLViewerRegion::accessToString(maturity)
-            << "' [value:" << static_cast<U32>(maturity)
-            << "], " << LL_ENDL;
-    }
-    handlePreferredMaturityResult(maturity);
-}
-
-// Using a new capability, tell the simulator that we want it to send everything
-// it knows about and not just what is in front of the camera, in its view
-// frustum. We need this feature so that the contents of the region that appears
-// in the 6 snapshots which we cannot see and is normally not "considered", is
-// also rendered. Typically, this is turned on when the 360 capture floater is
-// opened and turned off when it is closed.
-// Note: for this version, we do not have a way to determine when "everything"
-// has arrived and has been rendered so for now, the proposal is that users
-// will need to experiment with the low resolution version and wait for some
-// (hopefully) small period of time while the full contents resolves.
-// Pass in a flag to ask the simulator/interest list to "send everything" or
-// not (the default mode)
-void LLAgent::changeInterestListMode(const std::string &new_mode)
-{
-    if (new_mode != mInterestListMode)
-    {
-        mInterestListMode = new_mode;
-
-        // Change interest list mode for all regions.  If they are already set for the current mode,
-        // the setting will have no effect.
-        for (LLWorld::region_list_t::const_iterator iter = LLWorld::getInstance()->getRegionList().begin();
-             iter != LLWorld::getInstance()->getRegionList().end();
-             ++iter)
-        {
-            LLViewerRegion *regionp = *iter;
-            if (regionp && regionp->isAlive() && regionp->capabilitiesReceived())
-            {
-                regionp->setInterestListMode(mInterestListMode);
-            }
-        }
-    }
-	else
-	{
-		LL_DEBUGS("360Capture") << "Agent interest list mode is already set to " << mInterestListMode << LL_ENDL;
-	}
-}
-
-
-bool LLAgent::requestPostCapability(const std::string &capName, LLSD &postData, httpCallback_t cbSuccess, httpCallback_t cbFailure)
-{
-    if (getRegion())
-    {
-        return getRegion()->requestPostCapability(capName, postData, cbSuccess, cbFailure);
-    }
-	return false;
-}
-
-bool LLAgent::requestGetCapability(const std::string &capName, httpCallback_t cbSuccess, httpCallback_t cbFailure)
-{
-    if (getRegion())
-    {
-        return getRegion()->requestGetCapability(capName, cbSuccess, cbFailure);
-    }
-    return false;
-}
-
-bool LLAgent::getAdminOverride() const	
-{ 
-	return mAgentAccess->getAdminOverride(); 
-}
-
-void LLAgent::setMaturity(char text)
-{
-	mAgentAccess->setMaturity(text);
-}
-
-void LLAgent::setAdminOverride(bool b)	
-{ 
-	mAgentAccess->setAdminOverride(b);
-}
-
-void LLAgent::setGodLevel(U8 god_level)	
-{ 
-	mAgentAccess->setGodLevel(god_level);
-	mGodLevelChangeSignal(god_level);
-}
-
-LLAgent::god_level_change_slot_t LLAgent::registerGodLevelChanageListener(god_level_change_callback_t pGodLevelChangeCallback)
-{
-	return mGodLevelChangeSignal.connect(pGodLevelChangeCallback);
-}
-
-const LLAgentAccess& LLAgent::getAgentAccess()
-{
-	return *mAgentAccess;
-}
-
-bool LLAgent::validateMaturity(const LLSD& newvalue)
-{
-	return mAgentAccess->canSetMaturity(newvalue.asInteger());
-}
-
-void LLAgent::handleMaturity(const LLSD &pNewValue)
-{
-	sendMaturityPreferenceToServer(static_cast<U8>(pNewValue.asInteger()));
-}
-
-//----------------------------------------------------------------------------
-
-//*TODO remove, is not used anywhere as of August 20, 2009
-void LLAgent::buildFullnameAndTitle(std::string& name) const
-{
-	if (isGroupMember())
-	{
-		name = mGroupTitle;
-		name += ' ';
-	}
-	else
-	{
-		name.erase(0, name.length());
-	}
-
-	if (isAgentAvatarValid())
-	{
-		name += gAgentAvatarp->getFullname();
-	}
-}
-
-bool LLAgent::isInGroup(const LLUUID& group_id, bool ignore_god_mode /* false */) const
-{
-	if (!ignore_god_mode && isGodlike())
-		return true;
-
-	U32 count = mGroups.size();
-	for(U32 i = 0; i < count; ++i)
-	{
-		if(mGroups[i].mID == group_id)
-		{
-			return true;
-		}
-	}
-	return false;
-}
-
-// This implementation should mirror LLAgentInfo::hasPowerInGroup
-bool LLAgent::hasPowerInGroup(const LLUUID& group_id, U64 power) const
-{
-	if (isGodlikeWithoutAdminMenuFakery())
-		return true;
-
-	// GP_NO_POWERS can also mean no power is enough to grant an ability.
-	if (GP_NO_POWERS == power) return false;
-
-	U32 count = mGroups.size();
-	for(U32 i = 0; i < count; ++i)
-	{
-		if(mGroups[i].mID == group_id)
-		{
-			return (bool)((mGroups[i].mPowers & power) > 0);
-		}
-	}
-	return false;
-}
-
-bool LLAgent::hasPowerInActiveGroup(U64 power) const
-{
-	return (mGroupID.notNull() && (hasPowerInGroup(mGroupID, power)));
-}
-
-U64 LLAgent::getPowerInGroup(const LLUUID& group_id) const
-{
-	if (isGodlike())
-		return GP_ALL_POWERS;
-	
-	U32 count = mGroups.size();
-	for(U32 i = 0; i < count; ++i)
-	{
-		if(mGroups[i].mID == group_id)
-		{
-			return (mGroups[i].mPowers);
-		}
-	}
-
-	return GP_NO_POWERS;
-}
-
-bool LLAgent::getGroupData(const LLUUID& group_id, LLGroupData& data) const
-{
-	S32 count = mGroups.size();
-	for(S32 i = 0; i < count; ++i)
-	{
-		if(mGroups[i].mID == group_id)
-		{
-			data = mGroups[i];
-			return true;
-		}
-	}
-	return false;
-}
-
-S32 LLAgent::getGroupContribution(const LLUUID& group_id) const
-{
-	S32 count = mGroups.size();
-	for(S32 i = 0; i < count; ++i)
-	{
-		if(mGroups[i].mID == group_id)
-		{
-			S32 contribution = mGroups[i].mContribution;
-			return contribution;
-		}
-	}
-	return 0;
-}
-
-bool LLAgent::setGroupContribution(const LLUUID& group_id, S32 contribution)
-{
-	S32 count = mGroups.size();
-	for(S32 i = 0; i < count; ++i)
-	{
-		if(mGroups[i].mID == group_id)
-		{
-			mGroups[i].mContribution = contribution;
-			LLMessageSystem* msg = gMessageSystem;
-			msg->newMessage("SetGroupContribution");
-			msg->nextBlock("AgentData");
-			msg->addUUID("AgentID", gAgentID);
-			msg->addUUID("SessionID", gAgentSessionID);
-			msg->nextBlock("Data");
-			msg->addUUID("GroupID", group_id);
-			msg->addS32("Contribution", contribution);
-			sendReliableMessage();
-			return true;
-		}
-	}
-	return false;
-}
-
-bool LLAgent::setUserGroupFlags(const LLUUID& group_id, bool accept_notices, bool list_in_profile)
-{
-	S32 count = mGroups.size();
-	for(S32 i = 0; i < count; ++i)
-	{
-		if(mGroups[i].mID == group_id)
-		{
-			mGroups[i].mAcceptNotices = accept_notices;
-			mGroups[i].mListInProfile = list_in_profile;
-			LLMessageSystem* msg = gMessageSystem;
-			msg->newMessage("SetGroupAcceptNotices");
-			msg->nextBlock("AgentData");
-			msg->addUUID("AgentID", gAgentID);
-			msg->addUUID("SessionID", gAgentSessionID);
-			msg->nextBlock("Data");
-			msg->addUUID("GroupID", group_id);
-			msg->addBOOL("AcceptNotices", accept_notices);
-			msg->nextBlock("NewData");
-			msg->addBOOL("ListInProfile", list_in_profile);
-			sendReliableMessage();
-			return true;
-		}
-	}
-	return false;
-}
-
-bool LLAgent::canJoinGroups() const
-{
-	return (S32)mGroups.size() < LLAgentBenefitsMgr::current().getGroupMembershipLimit();
-}
-
-LLQuaternion LLAgent::getHeadRotation()
-{
-	if (!isAgentAvatarValid() || !gAgentAvatarp->mPelvisp || !gAgentAvatarp->mHeadp)
-	{
-		return LLQuaternion::DEFAULT;
-	}
-
-	if (!gAgentCamera.cameraMouselook())
-	{
-		return gAgentAvatarp->getRotation();
-	}
-
-	// We must be in mouselook
-	LLVector3 look_dir( LLViewerCamera::getInstance()->getAtAxis() );
-	LLVector3 up = look_dir % mFrameAgent.getLeftAxis();
-	LLVector3 left = up % look_dir;
-
-	LLQuaternion rot(look_dir, left, up);
-	if (gAgentAvatarp->getParent())
-	{
-		rot = rot * ~gAgentAvatarp->getParent()->getRotation();
-	}
-
-	return rot;
-}
-
-void LLAgent::sendAnimationRequests(const std::vector<LLUUID> &anim_ids, EAnimRequest request)
-{
-	if (gAgentID.isNull())
-	{
-		return;
-	}
-
-	S32 num_valid_anims = 0;
-
-	LLMessageSystem* msg = gMessageSystem;
-	msg->newMessageFast(_PREHASH_AgentAnimation);
-	msg->nextBlockFast(_PREHASH_AgentData);
-	msg->addUUIDFast(_PREHASH_AgentID, getID());
-	msg->addUUIDFast(_PREHASH_SessionID, getSessionID());
-
-	for (const LLUUID& uuid : anim_ids)
-	{
-		if (uuid.notNull())
-		{
-			msg->nextBlockFast(_PREHASH_AnimationList);
-			msg->addUUIDFast(_PREHASH_AnimID, uuid);
-			msg->addBOOLFast(_PREHASH_StartAnim, request == ANIM_REQUEST_START);
-			num_valid_anims++;
-		}
-	}
-
-	msg->nextBlockFast(_PREHASH_PhysicalAvatarEventList);
-	msg->addBinaryDataFast(_PREHASH_TypeData, NULL, 0);
-	if (num_valid_anims)
-	{
-		sendReliableMessage();
-	}
-}
-
-void LLAgent::sendAnimationRequest(const LLUUID &anim_id, EAnimRequest request)
-{
-	if (gAgentID.isNull() || anim_id.isNull() || !mRegionp)
-	{
-		return;
-	}
-
-	LLMessageSystem* msg = gMessageSystem;
-	msg->newMessageFast(_PREHASH_AgentAnimation);
-	msg->nextBlockFast(_PREHASH_AgentData);
-	msg->addUUIDFast(_PREHASH_AgentID, getID());
-	msg->addUUIDFast(_PREHASH_SessionID, getSessionID());
-
-	msg->nextBlockFast(_PREHASH_AnimationList);
-	msg->addUUIDFast(_PREHASH_AnimID, anim_id);
-	msg->addBOOLFast(_PREHASH_StartAnim, request == ANIM_REQUEST_START);
-
-	msg->nextBlockFast(_PREHASH_PhysicalAvatarEventList);
-	msg->addBinaryDataFast(_PREHASH_TypeData, NULL, 0);
-	sendReliableMessage();
-}
-
-// Send a message to the region to stop the NULL animation state
-// This will reset animation state overrides for the agent.
-void LLAgent::sendAnimationStateReset()
-{
-	if (gAgentID.isNull() || !mRegionp)
-	{
-		return;
-	}
-
-	LLMessageSystem* msg = gMessageSystem;
-	msg->newMessageFast(_PREHASH_AgentAnimation);
-	msg->nextBlockFast(_PREHASH_AgentData);
-	msg->addUUIDFast(_PREHASH_AgentID, getID());
-	msg->addUUIDFast(_PREHASH_SessionID, getSessionID());
-
-	msg->nextBlockFast(_PREHASH_AnimationList);
-	msg->addUUIDFast(_PREHASH_AnimID, LLUUID::null );
-	msg->addBOOLFast(_PREHASH_StartAnim, false);
-
-	msg->nextBlockFast(_PREHASH_PhysicalAvatarEventList);
-	msg->addBinaryDataFast(_PREHASH_TypeData, NULL, 0);
-	sendReliableMessage();
-}
-
-
-// Send a message to the region to revoke sepecified permissions on ALL scripts in the region
-// If the target is an object in the region, permissions in scripts on that object are cleared.
-// If it is the region ID, all scripts clear the permissions for this agent
-void LLAgent::sendRevokePermissions(const LLUUID & target, U32 permissions)
-{
-	// Currently only the bits for SCRIPT_PERMISSION_TRIGGER_ANIMATION and SCRIPT_PERMISSION_OVERRIDE_ANIMATIONS
-	// are supported by the server.  Sending any other bits will cause the message to be dropped without changing permissions
-
-	if (gAgentID.notNull() && gMessageSystem)
-	{
-		LLMessageSystem* msg = gMessageSystem;
-		msg->newMessageFast(_PREHASH_RevokePermissions);
-		msg->nextBlockFast(_PREHASH_AgentData);
-		msg->addUUIDFast(_PREHASH_AgentID, getID());		// Must be our ID
-		msg->addUUIDFast(_PREHASH_SessionID, getSessionID());
-
-		msg->nextBlockFast(_PREHASH_Data);
-		msg->addUUIDFast(_PREHASH_ObjectID, target);		// Must be in the region
-		msg->addS32Fast(_PREHASH_ObjectPermissions, (S32) permissions);
-
-		sendReliableMessage();
-	}
-}
-
-void LLAgent::sendWalkRun(bool running)
-{
-	LLMessageSystem* msgsys = gMessageSystem;
-	if (msgsys)
-	{
-		msgsys->newMessageFast(_PREHASH_SetAlwaysRun);
-		msgsys->nextBlockFast(_PREHASH_AgentData);
-		msgsys->addUUIDFast(_PREHASH_AgentID, getID());
-		msgsys->addUUIDFast(_PREHASH_SessionID, getSessionID());
-		msgsys->addBOOLFast(_PREHASH_AlwaysRun, bool(running) );
-		sendReliableMessage();
-	}
-}
-
-void LLAgent::friendsChanged()
-{
-	LLCollectProxyBuddies collector;
-	LLAvatarTracker::instance().applyFunctor(collector);
-	mProxyForAgents = collector.mProxy;
-}
-
-bool LLAgent::isGrantedProxy(const LLPermissions& perm)
-{
-	return (mProxyForAgents.count(perm.getOwner()) > 0);
-}
-
-bool LLAgent::allowOperation(PermissionBit op,
-							 const LLPermissions& perm,
-							 U64 group_proxy_power,
-							 U8 god_minimum)
-{
-	// Check god level.
-	if (getGodLevel() >= god_minimum) return true;
-
-	if (!perm.isOwned()) return false;
-
-	// A group member with group_proxy_power can act as owner.
-	bool is_group_owned;
-	LLUUID owner_id;
-	perm.getOwnership(owner_id, is_group_owned);
-	LLUUID group_id(perm.getGroup());
-	LLUUID agent_proxy(getID());
-
-	if (is_group_owned)
-	{
-		if (hasPowerInGroup(group_id, group_proxy_power))
-		{
-			// Let the member assume the group's id for permission requests.
-			agent_proxy = owner_id;
-		}
-	}
-	else
-	{
-		// Check for granted mod permissions.
-		if ((PERM_OWNER != op) && isGrantedProxy(perm))
-		{
-			agent_proxy = owner_id;
-		}
-	}
-
-	// This is the group id to use for permission requests.
-	// Only group members may use this field.
-	LLUUID group_proxy = LLUUID::null;
-	if (group_id.notNull() && isInGroup(group_id))
-	{
-		group_proxy = group_id;
-	}
-
-	// We now have max ownership information.
-	if (PERM_OWNER == op)
-	{
-		// This this was just a check for ownership, we can now return the answer.
-		return (agent_proxy == owner_id);
-	}
-
-	return perm.allowOperationBy(op, agent_proxy, group_proxy);
-}
-
-const LLColor4 &LLAgent::getEffectColor()
-{
-	return *mEffectColor;
-}
-
-void LLAgent::setEffectColor(const LLColor4 &color)
-{
-	*mEffectColor = color;
-}
-
-void LLAgent::initOriginGlobal(const LLVector3d &origin_global)
-{
-	mAgentOriginGlobal = origin_global;
-}
-
-bool LLAgent::leftButtonGrabbed() const	
-{ 
-	const bool camera_mouse_look = gAgentCamera.cameraMouselook();
-	return (!camera_mouse_look && mControlsTakenCount[CONTROL_LBUTTON_DOWN_INDEX] > 0) 
-		|| (camera_mouse_look && mControlsTakenCount[CONTROL_ML_LBUTTON_DOWN_INDEX] > 0)
-		|| (!camera_mouse_look && mControlsTakenPassedOnCount[CONTROL_LBUTTON_DOWN_INDEX] > 0)
-		|| (camera_mouse_look && mControlsTakenPassedOnCount[CONTROL_ML_LBUTTON_DOWN_INDEX] > 0);
-}
-
-bool LLAgent::rotateGrabbed() const		
-{ 
-	return (mControlsTakenCount[CONTROL_YAW_POS_INDEX] > 0)
-		|| (mControlsTakenCount[CONTROL_YAW_NEG_INDEX] > 0); 
-}
-
-bool LLAgent::forwardGrabbed() const
-{ 
-	return (mControlsTakenCount[CONTROL_AT_POS_INDEX] > 0); 
-}
-
-bool LLAgent::backwardGrabbed() const
-{ 
-	return (mControlsTakenCount[CONTROL_AT_NEG_INDEX] > 0); 
-}
-
-bool LLAgent::upGrabbed() const		
-{ 
-	return (mControlsTakenCount[CONTROL_UP_POS_INDEX] > 0); 
-}
-
-bool LLAgent::downGrabbed() const	
-{ 
-	return (mControlsTakenCount[CONTROL_UP_NEG_INDEX] > 0); 
-}
-
-void update_group_floaters(const LLUUID& group_id)
-{
-	
-	LLGroupActions::refresh(group_id);
-	//*TODO Implement group update for Profile View 
-	// still actual as of July 31, 2009 (DZ)
-
-	gAgent.fireEvent(new LLOldEvents::LLEvent(&gAgent, "new group"), "");
-}
-
-// static
-void LLAgent::processAgentDropGroup(LLMessageSystem *msg, void **)
-{
-	LLUUID	agent_id;
-	msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_AgentID, agent_id );
-
-	if (agent_id != gAgentID)
-	{
-		LL_WARNS() << "processAgentDropGroup for agent other than me" << LL_ENDL;
-		return;
-	}
-
-	LLUUID	group_id;
-	msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_GroupID, group_id );
-
-	// Remove the group if it already exists remove it and add the new data to pick up changes.
-	LLGroupData gd;
-	gd.mID = group_id;
-	std::vector<LLGroupData>::iterator found_it = std::find(gAgent.mGroups.begin(), gAgent.mGroups.end(), gd);
-	if (found_it != gAgent.mGroups.end())
-	{
-		gAgent.mGroups.erase(found_it);
-		if (gAgent.getGroupID() == group_id)
-		{
-			gAgent.mGroupID.setNull();
-			gAgent.mGroupPowers = 0;
-			gAgent.mGroupName.clear();
-			gAgent.mGroupTitle.clear();
-		}
-		
-		// refresh all group information
-		gAgent.sendAgentDataUpdateRequest();
-
-		LLGroupMgr::getInstance()->clearGroupData(group_id);
-		// close the floater for this group, if any.
-		LLGroupActions::closeGroup(group_id);
-	}
-	else
-	{
-		LL_WARNS() << "processAgentDropGroup, agent is not part of group " << group_id << LL_ENDL;
-	}
-}
-
-class LLAgentDropGroupViewerNode : public LLHTTPNode
-{
-	virtual void post(
-		LLHTTPNode::ResponsePtr response,
-		const LLSD& context,
-		const LLSD& input) const
-	{
-
-		if (
-			!input.isMap() ||
-			!input.has("body") )
-		{
-			//what to do with badly formed message?
-			response->extendedResult(HTTP_BAD_REQUEST, LLSD("Invalid message parameters"));
-		}
-
-		LLSD body = input["body"];
-		if ( body.has("body") ) 
-		{
-			//stupid message system doubles up the "body"s
-			body = body["body"];
-		}
-
-		if (
-			body.has("AgentData") &&
-			body["AgentData"].isArray() &&
-			body["AgentData"][0].isMap() )
-		{
-			LL_INFOS() << "VALID DROP GROUP" << LL_ENDL;
-
-			//there is only one set of data in the AgentData block
-			LLSD agent_data = body["AgentData"][0];
-			LLUUID agent_id;
-			LLUUID group_id;
-
-			agent_id = agent_data["AgentID"].asUUID();
-			group_id = agent_data["GroupID"].asUUID();
-
-			if (agent_id != gAgentID)
-			{
-				LL_WARNS()
-					<< "AgentDropGroup for agent other than me" << LL_ENDL;
-
-				response->notFound();
-				return;
-			}
-
-			// Remove the group if it already exists remove it
-			// and add the new data to pick up changes.
-			LLGroupData gd;
-			gd.mID = group_id;
-			std::vector<LLGroupData>::iterator found_it = std::find(gAgent.mGroups.begin(), gAgent.mGroups.end(), gd);
-			if (found_it != gAgent.mGroups.end())
-			{
-				gAgent.mGroups.erase(found_it);
-				if (gAgent.getGroupID() == group_id)
-				{
-					gAgent.mGroupID.setNull();
-					gAgent.mGroupPowers = 0;
-					gAgent.mGroupName.clear();
-					gAgent.mGroupTitle.clear();
-				}
-		
-				// refresh all group information
-				gAgent.sendAgentDataUpdateRequest();
-
-				LLGroupMgr::getInstance()->clearGroupData(group_id);
-				// close the floater for this group, if any.
-				LLGroupActions::closeGroup(group_id);
-			}
-			else
-			{
-				LL_WARNS()
-					<< "AgentDropGroup, agent is not part of group "
-					<< group_id << LL_ENDL;
-			}
-
-			response->result(LLSD());
-		}
-		else
-		{
-			//what to do with badly formed message?
-			response->extendedResult(HTTP_BAD_REQUEST, LLSD("Invalid message parameters"));
-		}
-	}
-};
-
-LLHTTPRegistration<LLAgentDropGroupViewerNode>
-	gHTTPRegistrationAgentDropGroupViewerNode(
-		"/message/AgentDropGroup");
-
-// static
-void LLAgent::processAgentGroupDataUpdate(LLMessageSystem *msg, void **)
-{
-	LLUUID	agent_id;
-
-	msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_AgentID, agent_id );
-
-	if (agent_id != gAgentID)
-	{
-		LL_WARNS() << "processAgentGroupDataUpdate for agent other than me" << LL_ENDL;
-		return;
-	}	
-	
-	S32 count = msg->getNumberOfBlocksFast(_PREHASH_GroupData);
-	LLGroupData group;
-	bool need_floater_update = false;
-	for(S32 i = 0; i < count; ++i)
-	{
-		msg->getUUIDFast(_PREHASH_GroupData, _PREHASH_GroupID, group.mID, i);
-		msg->getUUIDFast(_PREHASH_GroupData, _PREHASH_GroupInsigniaID, group.mInsigniaID, i);
-		msg->getU64(_PREHASH_GroupData, "GroupPowers", group.mPowers, i);
-		msg->getBOOL(_PREHASH_GroupData, "AcceptNotices", group.mAcceptNotices, i);
-		msg->getS32(_PREHASH_GroupData, "Contribution", group.mContribution, i);
-		msg->getStringFast(_PREHASH_GroupData, _PREHASH_GroupName, group.mName, i);
-		
-		if(group.mID.notNull())
-		{
-			need_floater_update = true;
-			// Remove the group if it already exists remove it and add the new data to pick up changes.
-			std::vector<LLGroupData>::iterator found_it = std::find(gAgent.mGroups.begin(), gAgent.mGroups.end(), group);
-			if (found_it != gAgent.mGroups.end())
-			{
-				gAgent.mGroups.erase(found_it);
-			}
-			gAgent.mGroups.push_back(group);
-		}
-		if (need_floater_update)
-		{
-			update_group_floaters(group.mID);
-		}
-	}
-
-}
-
-class LLAgentGroupDataUpdateViewerNode : public LLHTTPNode
-{
-	virtual void post(
-		LLHTTPNode::ResponsePtr response,
-		const LLSD& context,
-		const LLSD& input) const
-	{
-		LLSD body = input["body"];
-		if(body.has("body"))
-			body = body["body"];
-		LLUUID agent_id = body["AgentData"][0]["AgentID"].asUUID();
-
-		if (agent_id != gAgentID)
-		{
-			LL_WARNS() << "processAgentGroupDataUpdate for agent other than me" << LL_ENDL;
-			return;
-		}	
-
-		LLSD group_data = body["GroupData"];
-
-		LLSD::array_iterator iter_group =
-			group_data.beginArray();
-		LLSD::array_iterator end_group =
-			group_data.endArray();
-		int group_index = 0;
-		for(; iter_group != end_group; ++iter_group)
-		{
-
-			LLGroupData group;
-			bool need_floater_update = false;
-
-			group.mID = (*iter_group)["GroupID"].asUUID();
-			group.mPowers = ll_U64_from_sd((*iter_group)["GroupPowers"]);
-			group.mAcceptNotices = (*iter_group)["AcceptNotices"].asBoolean();
-			group.mListInProfile = body["NewGroupData"][group_index]["ListInProfile"].asBoolean();
-			group.mInsigniaID = (*iter_group)["GroupInsigniaID"].asUUID();
-			group.mName = (*iter_group)["GroupName"].asString();
-			group.mContribution = (*iter_group)["Contribution"].asInteger();
-
-			group_index++;
-
-			if(group.mID.notNull())
-			{
-				need_floater_update = true;
-				// Remove the group if it already exists remove it and add the new data to pick up changes.
-				std::vector<LLGroupData>::iterator found_it = std::find(gAgent.mGroups.begin(), gAgent.mGroups.end(), group);
-				if (found_it != gAgent.mGroups.end())
-				{
-					gAgent.mGroups.erase(found_it);
-				}
-				gAgent.mGroups.push_back(group);
-			}
-			if (need_floater_update)
-			{
-				update_group_floaters(group.mID);
-			}
-		}
-	}
-};
-
-LLHTTPRegistration<LLAgentGroupDataUpdateViewerNode >
-	gHTTPRegistrationAgentGroupDataUpdateViewerNode ("/message/AgentGroupDataUpdate"); 
-
-// static
-void LLAgent::processAgentDataUpdate(LLMessageSystem *msg, void **)
-{
-	LLUUID	agent_id;
-
-	msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_AgentID, agent_id );
-
-	if (agent_id != gAgentID)
-	{
-		LL_WARNS() << "processAgentDataUpdate for agent other than me" << LL_ENDL;
-		return;
-	}
-
-	msg->getStringFast(_PREHASH_AgentData, _PREHASH_GroupTitle, gAgent.mGroupTitle);
-	LLUUID active_id;
-	msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_ActiveGroupID, active_id);
-
-
-	if(active_id.notNull())
-	{
-		gAgent.mGroupID = active_id;
-		msg->getU64(_PREHASH_AgentData, "GroupPowers", gAgent.mGroupPowers);
-		msg->getString(_PREHASH_AgentData, _PREHASH_GroupName, gAgent.mGroupName);
-	}
-	else
-	{
-		gAgent.mGroupID.setNull();
-		gAgent.mGroupPowers = 0;
-		gAgent.mGroupName.clear();
-	}		
-
-	update_group_floaters(active_id);
-}
-
-// static
-void LLAgent::processScriptControlChange(LLMessageSystem *msg, void **)
-{
-	S32 block_count = msg->getNumberOfBlocks("Data");
-	for (S32 block_index = 0; block_index < block_count; block_index++)
-	{
-		bool take_controls;
-		U32	controls;
-		bool passon;
-		U32 i;
-		msg->getBOOL("Data", "TakeControls", take_controls, block_index);
-		if (take_controls)
-		{
-			// take controls
-			msg->getU32("Data", "Controls", controls, block_index );
-			msg->getBOOL("Data", "PassToAgent", passon, block_index );
-			for (i = 0; i < TOTAL_CONTROLS; i++)
-			{
-				if (controls & ( 1 << i))
-				{
-					if (passon)
-					{
-						gAgent.mControlsTakenPassedOnCount[i]++;
-					}
-					else
-					{
-						gAgent.mControlsTakenCount[i]++;
-					}
-				}
-			}
-		}
-		else
-		{
-			// release controls
-			msg->getU32("Data", "Controls", controls, block_index );
-			msg->getBOOL("Data", "PassToAgent", passon, block_index );
-			for (i = 0; i < TOTAL_CONTROLS; i++)
-			{
-				if (controls & ( 1 << i))
-				{
-					if (passon)
-					{
-						gAgent.mControlsTakenPassedOnCount[i]--;
-						if (gAgent.mControlsTakenPassedOnCount[i] < 0)
-						{
-							gAgent.mControlsTakenPassedOnCount[i] = 0;
-						}
-					}
-					else
-					{
-						gAgent.mControlsTakenCount[i]--;
-						if (gAgent.mControlsTakenCount[i] < 0)
-						{
-							gAgent.mControlsTakenCount[i] = 0;
-						}
-					}
-				}
-			}
-		}
-	}
-}
-
-/*
-// static
-void LLAgent::processControlTake(LLMessageSystem *msg, void **)
-{
-	U32	controls;
-	msg->getU32("Data", "Controls", controls );
-	U32 passon;
-	msg->getBOOL("Data", "PassToAgent", passon );
-
-	S32 i;
-	S32 total_count = 0;
-	for (i = 0; i < TOTAL_CONTROLS; i++)
-	{
-		if (controls & ( 1 << i))
-		{
-			if (passon)
-			{
-				gAgent.mControlsTakenPassedOnCount[i]++;
-			}
-			else
-			{
-				gAgent.mControlsTakenCount[i]++;
-			}
-			total_count++;
-		}
-	}
-
-	// Any control taken?  If so, might be first time.
-	if (total_count > 0)
-	{
-		LLFirstUse::useOverrideKeys();
-	}
-}
-
-// static
-void LLAgent::processControlRelease(LLMessageSystem *msg, void **)
-{
-	U32	controls;
-	msg->getU32("Data", "Controls", controls );
-	U32 passon;
-	msg->getBOOL("Data", "PassToAgent", passon );
-
-	S32 i;
-	for (i = 0; i < TOTAL_CONTROLS; i++)
-	{
-		if (controls & ( 1 << i))
-		{
-			if (passon)
-			{
-				gAgent.mControlsTakenPassedOnCount[i]--;
-				if (gAgent.mControlsTakenPassedOnCount[i] < 0)
-				{
-					gAgent.mControlsTakenPassedOnCount[i] = 0;
-				}
-			}
-			else
-			{
-				gAgent.mControlsTakenCount[i]--;
-				if (gAgent.mControlsTakenCount[i] < 0)
-				{
-					gAgent.mControlsTakenCount[i] = 0;
-				}
-			}
-		}
-	}
-}
-*/
-
-bool LLAgent::anyControlGrabbed() const
-{
-	for (U32 i = 0; i < TOTAL_CONTROLS; i++)
-	{
-		if (gAgent.mControlsTakenCount[i] > 0)
-			return true;
-		if (gAgent.mControlsTakenPassedOnCount[i] > 0)
-			return true;
-	}
-	return false;
-}
-
-bool LLAgent::isControlGrabbed(S32 control_index) const
-{
-	return mControlsTakenCount[control_index] > 0;
-}
-
-void LLAgent::forceReleaseControls()
-{
-	gMessageSystem->newMessage("ForceScriptControlRelease");
-	gMessageSystem->nextBlock("AgentData");
-	gMessageSystem->addUUID("AgentID", getID());
-	gMessageSystem->addUUID("SessionID", getSessionID());
-	sendReliableMessage();
-}
-
-void LLAgent::setHomePosRegion( const U64& region_handle, const LLVector3& pos_region)
-{
-	mHaveHomePosition = true;
-	mHomeRegionHandle = region_handle;
-	mHomePosRegion = pos_region;
-}
-
-bool LLAgent::getHomePosGlobal( LLVector3d* pos_global )
-{
-	if(!mHaveHomePosition)
-	{
-		return false;
-	}
-	F32 x = 0;
-	F32 y = 0;
-	from_region_handle( mHomeRegionHandle, &x, &y);
-	pos_global->setVec( x + mHomePosRegion.mV[VX], y + mHomePosRegion.mV[VY], mHomePosRegion.mV[VZ] );
-	return true;
-}
-
-bool LLAgent::isInHomeRegion()
-{
-	if(!mHaveHomePosition)
-	{
-		return false;
-	}
-	if (!getRegion())
-	{
-		return false;
-	}
-	if (getRegion()->getHandle() != mHomeRegionHandle)
-	{
-		return false;
-	}
-	return true;
-}
-
-void LLAgent::clearVisualParams(void *data)
-{
-	if (isAgentAvatarValid())
-	{
-		gAgentAvatarp->clearVisualParamWeights();
-		gAgentAvatarp->updateVisualParams();
-	}
-}
-
-//---------------------------------------------------------------------------
-// Teleport
-//---------------------------------------------------------------------------
-
-// teleportCore() - stuff to do on any teleport
-// protected
-bool LLAgent::teleportCore(bool is_local)
-{
-    LL_DEBUGS("Teleport") << "In teleport core" << LL_ENDL;
-	if ((TELEPORT_NONE != mTeleportState) && (mTeleportState != TELEPORT_PENDING))
-	{
-		LL_WARNS() << "Attempt to teleport when already teleporting." << LL_ENDL;
-		return false;
-	}
-
-	// force stand up and stop a sitting animation (if any), see MAINT-3969
-	if (isAgentAvatarValid() && gAgentAvatarp->getParent() && gAgentAvatarp->isSitting())
-	{
-		gAgentAvatarp->getOffObject();
-	}
-
-#if 0
-	// This should not exist. It has been added, removed, added, and now removed again.
-	// This change needs to come from the simulator. Otherwise, the agent ends up out of
-	// sync with other viewers. Discuss in DEV-14145/VWR-6744 before reenabling.
-
-	// Stop all animation before actual teleporting 
-        if (isAgentAvatarValid())
-	{
-		for ( LLVOAvatar::AnimIterator anim_it= gAgentAvatarp->mPlayingAnimations.begin();
-		      anim_it != gAgentAvatarp->mPlayingAnimations.end();
-		      ++anim_it)
-               {
-                       gAgentAvatarp->stopMotion(anim_it->first);
-               }
-               gAgentAvatarp->processAnimationStateChanges();
-       }
-#endif
-
-	// Don't call LLFirstUse::useTeleport because we don't know
-	// yet if the teleport will succeed.  Look in 
-	// process_teleport_location_reply
-
-	// hide land floater too - it'll be out of date
-	LLFloaterReg::hideInstance("about_land");
-
-	// hide the Region/Estate floater
-	LLFloaterReg::hideInstance("region_info");
-
-	LLViewerParcelMgr::getInstance()->deselectLand();
-	LLViewerMediaFocus::getInstance()->clearFocus();
-
-	// Close all pie menus, deselect land, etc.
-	// Don't change the camera until we know teleport succeeded. JC
-	gAgentCamera.resetView(false);
-
-	// local logic
-	add(LLStatViewer::TELEPORT, 1);
-	if (is_local)
-	{
-		LL_INFOS("Teleport") << "Setting teleport state to TELEPORT_LOCAL" << LL_ENDL;
-		gAgent.setTeleportState( LLAgent::TELEPORT_LOCAL );
-	}
-	else
-	{
-		gTeleportDisplay = true;
-		LL_INFOS("Teleport") << "Non-local, setting teleport state to TELEPORT_START" << LL_ENDL;
-		gAgent.setTeleportState( LLAgent::TELEPORT_START );
-	}
-	make_ui_sound("UISndTeleportOut");
-	
-	// MBW -- Let the voice client know a teleport has begun so it can leave the existing channel.
-	// This was breaking the case of teleporting within a single sim.  Backing it out for now.
-//	LLVoiceClient::getInstance()->leaveChannel();
-	
-	return true;
-}
-
-bool LLAgent::hasRestartableFailedTeleportRequest()
-{
-	return ((mTeleportRequest != NULL) && (mTeleportRequest->getStatus() == LLTeleportRequest::kFailed) &&
-		mTeleportRequest->canRestartTeleport());
-}
-
-void LLAgent::restartFailedTeleportRequest()
-{
-    LL_INFOS("Teleport") << "Agent wishes to restart failed teleport." << LL_ENDL;
-	if (hasRestartableFailedTeleportRequest())
-	{
-		mTeleportRequest->setStatus(LLTeleportRequest::kRestartPending);
-		startTeleportRequest();
-	}
-}
-
-void LLAgent::clearTeleportRequest()
-{
-    if(LLVoiceClient::instanceExists())
-    {
-        LLVoiceClient::getInstance()->setHidden(false);
-    }
-	mTeleportRequest.reset();
-    mTPNeedsNeabyChatSeparator = false;
-}
-
-void LLAgent::setMaturityRatingChangeDuringTeleport(U8 pMaturityRatingChange)
-{
-	mIsMaturityRatingChangingDuringTeleport = true;
-	mMaturityRatingChange = pMaturityRatingChange;
-}
-
-void LLAgent::sheduleTeleportIM()
-{
-    // is supposed to be called during teleport so we are still waiting for parcel
-    mTPNeedsNeabyChatSeparator = true;
-}
-
-bool LLAgent::hasPendingTeleportRequest()
-{
-	return ((mTeleportRequest != NULL) &&
-		((mTeleportRequest->getStatus() == LLTeleportRequest::kPending) ||
-		(mTeleportRequest->getStatus() == LLTeleportRequest::kRestartPending)));
-}
-
-void LLAgent::startTeleportRequest()
-{
-    LL_INFOS("Telport") << "Agent handling start teleport request." << LL_ENDL;
-    if(LLVoiceClient::instanceExists())
-    {
-        LLVoiceClient::getInstance()->setHidden(true);
-    }
-	if (hasPendingTeleportRequest())
-	{
-		LLUIUsage::instance().logCommand("Agent.StartTeleportRequest");
-        mTeleportCanceled.reset();
-		if  (!isMaturityPreferenceSyncedWithServer())
-		{
-			gTeleportDisplay = true;
-			LL_INFOS("Teleport") << "Maturity preference not synced yet, setting teleport state to TELEPORT_PENDING" << LL_ENDL;
-			setTeleportState(TELEPORT_PENDING);
-		}
-		else
-		{
-			switch (mTeleportRequest->getStatus())
-			{
-			case LLTeleportRequest::kPending :
-				mTeleportRequest->setStatus(LLTeleportRequest::kStarted);
-				mTeleportRequest->startTeleport();
-				break;
-			case LLTeleportRequest::kRestartPending :
-				llassert(mTeleportRequest->canRestartTeleport());
-				mTeleportRequest->setStatus(LLTeleportRequest::kStarted);
-				mTeleportRequest->restartTeleport();
-				break;
-			default :
-				llassert(0);
-				break;
-			}
-		}
-	}
-}
-
-void LLAgent::handleTeleportFinished()
-{
-    LL_INFOS("Teleport") << "Agent handling teleport finished." << LL_ENDL;
-    if (mTPNeedsNeabyChatSeparator)
-    {
-        // parcel is ready at this point
-        addTPNearbyChatSeparator();
-        mTPNeedsNeabyChatSeparator = false;
-    }
-	clearTeleportRequest();
-    mTeleportCanceled.reset();
-	if (mIsMaturityRatingChangingDuringTeleport)
-	{
-		// notify user that the maturity preference has been changed
-		std::string maturityRating = LLViewerRegion::accessToString(mMaturityRatingChange);
-		LLStringUtil::toLower(maturityRating);
-		LLSD args;
-		args["RATING"] = maturityRating;
-		LLNotificationsUtil::add("PreferredMaturityChanged", args);
-		mIsMaturityRatingChangingDuringTeleport = false;
-	}
-    
-    if (mRegionp)
-    {
-        if (mRegionp->capabilitiesReceived())
-        {
-			LL_DEBUGS("Teleport") << "capabilities have been received for region handle "
-								  << mRegionp->getHandle()
-								  << " id " << mRegionp->getRegionID()
-								  << ", calling onCapabilitiesReceivedAfterTeleport()"
-								  << LL_ENDL;
-            onCapabilitiesReceivedAfterTeleport();
-        }
-        else
-        {
-			LL_DEBUGS("Teleport") << "Capabilities not yet received for region handle "
-								  << mRegionp->getHandle()
-								  << " id " << mRegionp->getRegionID()
-								  << LL_ENDL;
-            mRegionp->setCapabilitiesReceivedCallback(boost::bind(&LLAgent::onCapabilitiesReceivedAfterTeleport));
-        }
-    }
-    LLPerfStats::tunables.autoTuneTimeout = true;
-}
-
-void LLAgent::handleTeleportFailed()
-{
-    LL_WARNS("Teleport") << "Agent handling teleport failure!" << LL_ENDL;
-    if(LLVoiceClient::instanceExists())
-    {
-        LLVoiceClient::getInstance()->setHidden(false);
-    }
-
-    setTeleportState(LLAgent::TELEPORT_NONE);
-    // Unlock the UI if the progress bar has been shown.
-//     gViewerWindow->setShowProgress(false);
-//     gTeleportDisplay = false;
-
-    if (mTeleportRequest)
-	{
-		mTeleportRequest->setStatus(LLTeleportRequest::kFailed);
-	}
-	if (mIsMaturityRatingChangingDuringTeleport)
-	{
-		// notify user that the maturity preference has been changed
-		std::string maturityRating = LLViewerRegion::accessToString(mMaturityRatingChange);
-		LLStringUtil::toLower(maturityRating);
-		LLSD args;
-		args["RATING"] = maturityRating;
-		LLNotificationsUtil::add("PreferredMaturityChanged", args);
-		mIsMaturityRatingChangingDuringTeleport = false;
-	}
-
-    mTPNeedsNeabyChatSeparator = false;
-
-    LLPerfStats::tunables.autoTuneTimeout = true;
-}
-
-/*static*/
-void LLAgent::addTPNearbyChatSeparator()
-{
-    LLViewerRegion* agent_region = gAgent.getRegion();
-    LLParcel* agent_parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();
-    if (!agent_region || !agent_parcel)
-    {
-        return;
-    }
-
-    LLFloaterIMNearbyChat* nearby_chat = LLFloaterReg::getTypedInstance<LLFloaterIMNearbyChat>("nearby_chat");
-    if (nearby_chat)
-    {
-        std::string location_name;
-        LLAgentUI::ELocationFormat format = LLAgentUI::LOCATION_FORMAT_NO_MATURITY;
-
-        // Might be better to provide slurl to chat
-        if (!LLAgentUI::buildLocationString(location_name, format))
-        {
-            location_name = "Teleport to new region"; // Shouldn't happen
-        }
-
-        LLChat chat;
-        chat.mFromName = location_name;
-        chat.mMuted = false;
-        chat.mFromID = LLUUID::null;
-        chat.mSourceType = CHAT_SOURCE_TELEPORT;
-        chat.mChatStyle = CHAT_STYLE_TELEPORT_SEP;
-        chat.mText = "";
-
-        LLSD args;
-        args["do_not_log"] = true;
-        nearby_chat->addMessage(chat, true, args);
-    }
-}
-
-/*static*/
-void LLAgent::onCapabilitiesReceivedAfterTeleport()
-{
-	if (gAgent.getRegion())
-	{
-		LL_DEBUGS("Teleport") << "running after capabilities received callback has been triggered, agent region "
-							  << gAgent.getRegion()->getHandle()
-							  << " id " << gAgent.getRegion()->getRegionID()
-							  << " name " << gAgent.getRegion()->getName()
-							  << LL_ENDL;
-	}
-	else
-	{
-		LL_WARNS("Teleport") << "called when agent region is null!" << LL_ENDL;
-	}
-
-    check_merchant_status();
-}
-
-
-void LLAgent::teleportRequest(
-	const U64& region_handle,
-	const LLVector3& pos_local,
-	bool look_at_from_camera)
-{
-	LLViewerRegion* regionp = getRegion();
-	if (regionp && teleportCore(region_handle == regionp->getHandle()))
-	{
-		LL_INFOS("Teleport") << "Sending TeleportLocationRequest: '" << region_handle << "':"
-							 << pos_local << LL_ENDL;
-		LLMessageSystem* msg = gMessageSystem;
-		msg->newMessage("TeleportLocationRequest");
-		msg->nextBlockFast(_PREHASH_AgentData);
-		msg->addUUIDFast(_PREHASH_AgentID, getID());
-		msg->addUUIDFast(_PREHASH_SessionID, getSessionID());
-		msg->nextBlockFast(_PREHASH_Info);
-		msg->addU64("RegionHandle", region_handle);
-		msg->addVector3("Position", pos_local);
-		LLVector3 look_at(0,1,0);
-		if (look_at_from_camera)
-		{
-			look_at = LLViewerCamera::getInstance()->getAtAxis();
-		}
-		msg->addVector3("LookAt", look_at);
-		sendReliableMessage();
-	}
-}
-
-// Landmark ID = LLUUID::null means teleport home
-void LLAgent::teleportViaLandmark(const LLUUID& landmark_asset_id)
-{
-    if (landmark_asset_id.isNull())
-    {
-        gAgentCamera.resetView();
-    }
-	mTeleportRequest = LLTeleportRequestPtr(new LLTeleportRequestViaLandmark(landmark_asset_id));
-	startTeleportRequest();
-}
-
-void LLAgent::doTeleportViaLandmark(const LLUUID& landmark_asset_id)
-{
-	LLViewerRegion *regionp = getRegion();
-	if(regionp && teleportCore())
-	{
-		LL_INFOS("Teleport") << "Sending TeleportLandmarkRequest. Current region handle " << regionp->getHandle()
-							 << " region id " << regionp->getRegionID()
-							 << " requested landmark id " << landmark_asset_id
-							 << LL_ENDL;
-
-		LLMessageSystem* msg = gMessageSystem;
-		msg->newMessageFast(_PREHASH_TeleportLandmarkRequest);
-		msg->nextBlockFast(_PREHASH_Info);
-		msg->addUUIDFast(_PREHASH_AgentID, getID());
-		msg->addUUIDFast(_PREHASH_SessionID, getSessionID());
-		msg->addUUIDFast(_PREHASH_LandmarkID, landmark_asset_id);
-		sendReliableMessage();
-	}
-}
-
-void LLAgent::teleportViaLure(const LLUUID& lure_id, bool godlike)
-{
-	mTeleportRequest = LLTeleportRequestPtr(new LLTeleportRequestViaLure(lure_id, godlike));
-	startTeleportRequest();
-}
-
-void LLAgent::doTeleportViaLure(const LLUUID& lure_id, bool godlike)
-{
-	LLViewerRegion* regionp = getRegion();
-	if(regionp && teleportCore())
-	{
-		U32 teleport_flags = 0x0;
-		if (godlike)
-		{
-			teleport_flags |= TELEPORT_FLAGS_VIA_GODLIKE_LURE;
-			teleport_flags |= TELEPORT_FLAGS_DISABLE_CANCEL;
-		}
-		else
-		{
-			teleport_flags |= TELEPORT_FLAGS_VIA_LURE;
-		}
-
-		LL_INFOS("Teleport") << "Sending TeleportLureRequest."
-							 << " Current region handle " << regionp->getHandle()
-							 << " region id " << regionp->getRegionID()
-							 << " lure id " << lure_id
-							 << LL_ENDL;
-		// send the message
-		LLMessageSystem* msg = gMessageSystem;
-		msg->newMessageFast(_PREHASH_TeleportLureRequest);
-		msg->nextBlockFast(_PREHASH_Info);
-		msg->addUUIDFast(_PREHASH_AgentID, getID());
-		msg->addUUIDFast(_PREHASH_SessionID, getSessionID());
-		msg->addUUIDFast(_PREHASH_LureID, lure_id);
-		// teleport_flags is a legacy field, now derived sim-side:
-		msg->addU32("TeleportFlags", teleport_flags);
-		sendReliableMessage();
-	}	
-}
-
-
-// James Cook, July 28, 2005
-void LLAgent::teleportCancel()
-{
-	if (!hasPendingTeleportRequest())
-	{
-		LLViewerRegion* regionp = getRegion();
-		if(regionp)
-		{
-			LL_INFOS("Teleport") << "Sending TeleportCancel" << LL_ENDL;
-			
-			// send the message
-			LLMessageSystem* msg = gMessageSystem;
-			msg->newMessage("TeleportCancel");
-			msg->nextBlockFast(_PREHASH_Info);
-			msg->addUUIDFast(_PREHASH_AgentID, getID());
-			msg->addUUIDFast(_PREHASH_SessionID, getSessionID());
-			sendReliableMessage();
-		}
-		mTeleportCanceled = mTeleportRequest;
-	}
-	clearTeleportRequest();
-	gAgent.setTeleportState( LLAgent::TELEPORT_NONE );
-}
-
-void LLAgent::restoreCanceledTeleportRequest()
-{
-    if (mTeleportCanceled != NULL)
-    {
-		LL_INFOS() << "Restoring canceled teleport request, setting state to TELEPORT_REQUESTED" << LL_ENDL;
-        gAgent.setTeleportState( LLAgent::TELEPORT_REQUESTED );
-        mTeleportRequest = mTeleportCanceled;
-        mTeleportCanceled.reset();
-        gTeleportDisplay = true;
-        gTeleportDisplayTimer.reset();
-    }
-}
-
-void LLAgent::teleportViaLocation(const LLVector3d& pos_global)
-{
-	mTeleportRequest = LLTeleportRequestPtr(new LLTeleportRequestViaLocation(pos_global));
-	startTeleportRequest();
-}
-
-void LLAgent::doTeleportViaLocation(const LLVector3d& pos_global)
-{
-	LLViewerRegion* regionp = getRegion();
-
-	if (!regionp)
-	{
-		return;
-	}
-
-	U64 handle = to_region_handle(pos_global);
-	LLSimInfo* info = LLWorldMap::getInstance()->simInfoFromHandle(handle);
-	if(regionp && info)
-	{
-		LLVector3d region_origin = info->getGlobalOrigin();
-		LLVector3 pos_local(
-			(F32)(pos_global.mdV[VX] - region_origin.mdV[VX]),
-			(F32)(pos_global.mdV[VY] - region_origin.mdV[VY]),
-			(F32)(pos_global.mdV[VZ]));
-		teleportRequest(handle, pos_local);
-	}
-	else if(regionp && 
-		teleportCore(regionp->getHandle() == to_region_handle_global((F32)pos_global.mdV[VX], (F32)pos_global.mdV[VY])))
-	{
-		// send the message
-		LLMessageSystem* msg = gMessageSystem;
-		msg->newMessageFast(_PREHASH_TeleportLocationRequest);
-		msg->nextBlockFast(_PREHASH_AgentData);
-		msg->addUUIDFast(_PREHASH_AgentID, getID());
-		msg->addUUIDFast(_PREHASH_SessionID, getSessionID());
-
-		msg->nextBlockFast(_PREHASH_Info);
-		F32 width = regionp->getWidth();
-		LLVector3 pos(fmod((F32)pos_global.mdV[VX], width),
-					  fmod((F32)pos_global.mdV[VY], width),
-					  (F32)pos_global.mdV[VZ]);
-		F32 region_x = (F32)(pos_global.mdV[VX]);
-		F32 region_y = (F32)(pos_global.mdV[VY]);
-		U64 region_handle = to_region_handle_global(region_x, region_y);
-		msg->addU64Fast(_PREHASH_RegionHandle, region_handle);
-		msg->addVector3Fast(_PREHASH_Position, pos);
-		pos.mV[VX] += 1;
-		msg->addVector3Fast(_PREHASH_LookAt, pos);
-
-		LL_WARNS("Teleport") << "Sending deprecated(?) TeleportLocationRequest."
-							 << " pos_global " << pos_global
-							 << " region_x " << region_x
-							 << " region_y " << region_y
-							 << " region_handle " << region_handle
-							 << LL_ENDL; 
-
-		sendReliableMessage();
-	}
-}
-
-// Teleport to global position, but keep facing in the same direction 
-void LLAgent::teleportViaLocationLookAt(const LLVector3d& pos_global)
-{
-	mTeleportRequest = LLTeleportRequestPtr(new LLTeleportRequestViaLocationLookAt(pos_global));
-	startTeleportRequest();
-}
-
-void LLAgent::doTeleportViaLocationLookAt(const LLVector3d& pos_global)
-{
-	mbTeleportKeepsLookAt = true;
-
-	if(!gAgentCamera.isfollowCamLocked())
-	{
-		gAgentCamera.setFocusOnAvatar(false, ANIMATE);	// detach camera form avatar, so it keeps direction
-	}
-
-	U64 region_handle = to_region_handle(pos_global);
-	LLVector3 pos_local = (LLVector3)(pos_global - from_region_handle(region_handle));
-	teleportRequest(region_handle, pos_local, getTeleportKeepsLookAt());
-}
-
-LLAgent::ETeleportState	LLAgent::getTeleportState() const
-{
-    return (mTeleportRequest && (mTeleportRequest->getStatus() == LLTeleportRequest::kFailed)) ? 
-        TELEPORT_NONE : mTeleportState;
-}
-
-
-void LLAgent::setTeleportState(ETeleportState state)
-{
-    if (mTeleportRequest && (state != TELEPORT_NONE) && (mTeleportRequest->getStatus() == LLTeleportRequest::kFailed))
-    {   // A late message has come in regarding a failed teleport.  
-        // We have already decided that it failed so should not reinitiate the teleport sequence in the viewer.
-        LL_WARNS("Teleport") << "Attempt to set teleport state to " << state <<
-            " for previously failed teleport.  Ignore!" << LL_ENDL;
-        return;
-    }
-    LL_DEBUGS("Teleport") << "Setting teleport state to "
-						  << LLAgent::teleportStateName(state) << "(" << state << ")"
-						  << " Previous state: "
-						  << teleportStateName(mTeleportState) << "(" << mTeleportState << ")"
-						  << LL_ENDL;
-	mTeleportState = state;
-	if (mTeleportState > TELEPORT_NONE && gSavedSettings.getBOOL("FreezeTime"))
-	{
-		LLFloaterReg::hideInstance("snapshot");
-	}
-
-	switch (mTeleportState)
-	{
-		case TELEPORT_NONE:
-			mbTeleportKeepsLookAt = false;
-			break;
-
-		case TELEPORT_MOVING:
-		// We're outa here. Save "back" slurl.
-		LLAgentUI::buildSLURL(*mTeleportSourceSLURL);
-			break;
-
-		case TELEPORT_ARRIVING:
-		// First two position updates after a teleport tend to be weird
-		//LLViewerStats::getInstance()->mAgentPositionSnaps.mCountOfNextUpdatesToIgnore = 2;
-
-		// Let the interested parties know we've teleported.
-		LLViewerParcelMgr::getInstance()->onTeleportFinished(false, getPositionGlobal());
-			break;
-
-		default:
-			break;
-	}
-}
-
-
-void LLAgent::stopCurrentAnimations()
-{
-    LL_DEBUGS("Avatar") << "Stopping current animations" << LL_ENDL;
-
-	// This function stops all current overriding animations on this
-	// avatar, propagating this change back to the server.
-	if (isAgentAvatarValid())
-	{
-		std::vector<LLUUID> anim_ids;
-
-		for ( LLVOAvatar::AnimIterator anim_it =
-			      gAgentAvatarp->mPlayingAnimations.begin();
-		      anim_it != gAgentAvatarp->mPlayingAnimations.end();
-		      anim_it++)
-		{
-			if ((anim_it->first == ANIM_AGENT_DO_NOT_DISTURB)||
-				(anim_it->first == ANIM_AGENT_SIT_GROUND_CONSTRAINED))
-			{
-				// don't cancel a ground-sit anim, as viewers
-				// use this animation's status in
-				// determining whether we're sitting. ick.
-                LL_DEBUGS("Avatar") << "sit or do-not-disturb animation will not be stopped" << LL_ENDL;
-			}
-			else
-			{
-				// stop this animation locally
-				gAgentAvatarp->stopMotion(anim_it->first, true);
-				// ...and tell the server to tell everyone.
-				anim_ids.push_back(anim_it->first);
-			}
-		}
-
-		sendAnimationRequests(anim_ids, ANIM_REQUEST_STOP);
-
-		// Tell the region to clear any animation state overrides
-		sendAnimationStateReset();
-
-		// Revoke all animation permissions
-		if (mRegionp &&
-			gSavedSettings.getBOOL("RevokePermsOnStopAnimation"))
-		{
-			U32 permissions = SCRIPT_PERMISSIONS[SCRIPT_PERMISSION_TRIGGER_ANIMATION].permbit | SCRIPT_PERMISSIONS[SCRIPT_PERMISSION_OVERRIDE_ANIMATIONS].permbit;
-			sendRevokePermissions(mRegionp->getRegionID(), permissions);
-			if (gAgentAvatarp->isSitting())
-			{	// Also stand up, since auto-granted sit animation permission has been revoked
-				gAgent.standUp();
-			}
-		}
-
-		// re-assert at least the default standing animation, because
-		// viewers get confused by avs with no associated anims.
-		sendAnimationRequest(ANIM_AGENT_STAND, ANIM_REQUEST_START);
-	}
-}
-
-void LLAgent::fidget()
-{
-	if (!getAFK())
-	{
-		F32 curTime = mFidgetTimer.getElapsedTimeF32();
-		if (curTime > mNextFidgetTime)
-		{
-			// pick a random fidget anim here
-			S32 oldFidget = mCurrentFidget;
-
-			mCurrentFidget = ll_rand(NUM_AGENT_STAND_ANIMS);
-
-			if (mCurrentFidget != oldFidget)
-			{
-				LLAgent::stopFidget();
-
-				
-				switch(mCurrentFidget)
-				{
-				case 0:
-					mCurrentFidget = 0;
-					break;
-				case 1:
-					sendAnimationRequest(ANIM_AGENT_STAND_1, ANIM_REQUEST_START);
-					mCurrentFidget = 1;
-					break;
-				case 2:
-					sendAnimationRequest(ANIM_AGENT_STAND_2, ANIM_REQUEST_START);
-					mCurrentFidget = 2;
-					break;
-				case 3:
-					sendAnimationRequest(ANIM_AGENT_STAND_3, ANIM_REQUEST_START);
-					mCurrentFidget = 3;
-					break;
-				case 4:
-					sendAnimationRequest(ANIM_AGENT_STAND_4, ANIM_REQUEST_START);
-					mCurrentFidget = 4;
-					break;
-				}
-			}
-
-			// calculate next fidget time
-			mNextFidgetTime = curTime + ll_frand(MAX_FIDGET_TIME - MIN_FIDGET_TIME) + MIN_FIDGET_TIME;
-		}
-	}
-}
-
-void LLAgent::stopFidget()
-{
-	std::vector<LLUUID> anims;
-	anims.reserve(4);
-	anims.push_back(ANIM_AGENT_STAND_1);
-	anims.push_back(ANIM_AGENT_STAND_2);
-	anims.push_back(ANIM_AGENT_STAND_3);
-	anims.push_back(ANIM_AGENT_STAND_4);
-
-	gAgent.sendAnimationRequests(anims, ANIM_REQUEST_STOP);
-}
-
-
-void LLAgent::requestEnterGodMode()
-{
-	LLMessageSystem* msg = gMessageSystem;
-	msg->newMessageFast(_PREHASH_RequestGodlikePowers);
-	msg->nextBlockFast(_PREHASH_AgentData);
-	msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
-	msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
-	msg->nextBlockFast(_PREHASH_RequestBlock);
-	msg->addBOOLFast(_PREHASH_Godlike, true);
-	msg->addUUIDFast(_PREHASH_Token, LLUUID::null);
-
-	// simulators need to know about your request
-	sendReliableMessage();
-}
-
-void LLAgent::requestLeaveGodMode()
-{
-	LLMessageSystem* msg = gMessageSystem;
-	msg->newMessageFast(_PREHASH_RequestGodlikePowers);
-	msg->nextBlockFast(_PREHASH_AgentData);
-	msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());
-	msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
-	msg->nextBlockFast(_PREHASH_RequestBlock);
-	msg->addBOOLFast(_PREHASH_Godlike, false);
-	msg->addUUIDFast(_PREHASH_Token, LLUUID::null);
-
-	// simulator needs to know about your request
-	sendReliableMessage();
-}
-
-void LLAgent::sendAgentDataUpdateRequest()
-{
-	gMessageSystem->newMessageFast(_PREHASH_AgentDataUpdateRequest);
-	gMessageSystem->nextBlockFast(_PREHASH_AgentData);
-	gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );
-	gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());
-	sendReliableMessage();
-}
-
-void LLAgent::sendAgentUserInfoRequest()
-{
-    std::string cap;
-
-    if (getID().isNull())
-        return; // not logged in
-
-    if (mRegionp)
-        cap = mRegionp->getCapability("UserInfo");
-
-    if (!cap.empty())
-    {
-        LLCoros::instance().launch("requestAgentUserInfoCoro",
-            boost::bind(&LLAgent::requestAgentUserInfoCoro, this, cap));
-    }
-    else
-    { 
-        sendAgentUserInfoRequestMessage();
-    }
-}
-
-void LLAgent::requestAgentUserInfoCoro(std::string capurl)
-{
-    LLCore::HttpRequest::policy_t httpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID);
-    LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
-        httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("requestAgentUserInfoCoro", httpPolicy));
-    LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
-    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
-    LLCore::HttpHeaders::ptr_t httpHeaders;
-
-    httpOpts->setFollowRedirects(true);
-
-    LLSD result = httpAdapter->getAndSuspend(httpRequest, capurl, httpOpts, httpHeaders);
-
-    LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
-    LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
-
-    if (!status)
-    {
-        LL_WARNS("UserInfo") << "Failed to get user information." << LL_ENDL;
-        return;
-    }
-    else if (!result["success"].asBoolean())
-    {
-        LL_WARNS("UserInfo") << "Failed to get user information: " << result["message"] << LL_ENDL;
-        return;
-    }
-
-    std::string email;
-    std::string dir_visibility;
-
-    email = result["email"].asString();
-    dir_visibility = result["directory_visibility"].asString();
-
-    // TODO: This should probably be changed.  I'm not entirely comfortable 
-    // having LLAgent interact directly with the UI in this way.
-    LLFloaterPreference::updateUserInfo(dir_visibility);
-    LLFloaterSnapshot::setAgentEmail(email);
-}
-
-void LLAgent::sendAgentUpdateUserInfo(const std::string& directory_visibility)
-{
-    std::string cap;
-
-    if (getID().isNull())
-        return; // not logged in
-
-    if (mRegionp)
-        cap = mRegionp->getCapability("UserInfo");
-
-    if (!cap.empty())
-    {
-        LLCoros::instance().launch("updateAgentUserInfoCoro",
-            boost::bind(&LLAgent::updateAgentUserInfoCoro, this, cap, directory_visibility));
-    }
-    else
-    {
-        sendAgentUpdateUserInfoMessage(directory_visibility);
-    }
-}
-
-
-void LLAgent::updateAgentUserInfoCoro(std::string capurl, std::string directory_visibility)
-{
-    LLCore::HttpRequest::policy_t httpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID);
-    LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t
-        httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("requestAgentUserInfoCoro", httpPolicy));
-    LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);
-    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);
-    LLCore::HttpHeaders::ptr_t httpHeaders;
-
-    httpOpts->setFollowRedirects(true);
-    LLSD body(LLSDMap
-        ("dir_visibility",  LLSD::String(directory_visibility)));
-
-
-    LLSD result = httpAdapter->postAndSuspend(httpRequest, capurl, body, httpOpts, httpHeaders);
-
-    LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];
-    LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);
-
-    if (!status)
-    {
-        LL_WARNS("UserInfo") << "Failed to set user information." << LL_ENDL;
-    }
-    else if (!result["success"].asBoolean())
-    {
-        LL_WARNS("UserInfo") << "Failed to set user information: " << result["message"] << LL_ENDL;
-    }
-}
-
-// deprecated:
-// May be removed when UserInfo cap propagates to all simhosts in grid
-void LLAgent::sendAgentUserInfoRequestMessage()
-{
-    gMessageSystem->newMessageFast(_PREHASH_UserInfoRequest);
-    gMessageSystem->nextBlockFast(_PREHASH_AgentData);
-    gMessageSystem->addUUIDFast(_PREHASH_AgentID, getID());
-    gMessageSystem->addUUIDFast(_PREHASH_SessionID, getSessionID());
-    sendReliableMessage();
-}
-
-void LLAgent::sendAgentUpdateUserInfoMessage(const std::string& directory_visibility)
-{
-    gMessageSystem->newMessageFast(_PREHASH_UpdateUserInfo);
-    gMessageSystem->nextBlockFast(_PREHASH_AgentData);
-    gMessageSystem->addUUIDFast(_PREHASH_AgentID, getID());
-    gMessageSystem->addUUIDFast(_PREHASH_SessionID, getSessionID());
-    gMessageSystem->nextBlockFast(_PREHASH_UserData);
-    gMessageSystem->addString("DirectoryVisibility", directory_visibility);
-    gAgent.sendReliableMessage();
-
-}
-// end deprecated
-//------
-
-void LLAgent::observeFriends()
-{
-	if(!mFriendObserver)
-	{
-		mFriendObserver = new LLAgentFriendObserver;
-		LLAvatarTracker::instance().addObserver(mFriendObserver);
-		friendsChanged();
-	}
-}
-
-std::map<S32, std::string> LLAgent::sTeleportStateName = { { TELEPORT_NONE, "TELEPORT_NONE" },
-														   { TELEPORT_START, "TELEPORT_START" },
-														   { TELEPORT_REQUESTED, "TELEPORT_REQUESTED" },
-														   { TELEPORT_MOVING, "TELEPORT_MOVING" },
-														   { TELEPORT_START_ARRIVAL, "TELEPORT_START_ARRIVAL" },
-														   { TELEPORT_ARRIVING, "TELEPORT_ARRIVING" },
-														   { TELEPORT_LOCAL, "TELEPORT_LOCAL" },
-														   { TELEPORT_PENDING, "TELEPORT_PENDING" } };
-
-const std::string& LLAgent::teleportStateName(S32 state)
-{
-	static std::string invalid_state_str("INVALID");
-	auto iter = LLAgent::sTeleportStateName.find(state);
-	if (iter != LLAgent::sTeleportStateName.end())
-	{
-		return iter->second;
-	}
-	else
-	{
-		return invalid_state_str;
-	}
-}
-
-const std::string& LLAgent::getTeleportStateName() const
-{
-	return teleportStateName(getTeleportState());
-}
-
-void LLAgent::parseTeleportMessages(const std::string& xml_filename)
-{
-	LLXMLNodePtr root;
-	bool success = LLUICtrlFactory::getLayeredXMLNode(xml_filename, root);
-
-	if (!success || !root || !root->hasName( "teleport_messages" ))
-	{
-		LL_ERRS() << "Problem reading teleport string XML file: " 
-			   << xml_filename << LL_ENDL;
-		return;
-	}
-
-	for (LLXMLNode* message_set = root->getFirstChild();
-		 message_set != NULL;
-		 message_set = message_set->getNextSibling())
-	{
-		if ( !message_set->hasName("message_set") ) continue;
-
-		std::map<std::string, std::string> *teleport_msg_map = NULL;
-		std::string message_set_name;
-
-		if ( message_set->getAttributeString("name", message_set_name) )
-		{
-			//now we loop over all the string in the set and add them
-			//to the appropriate set
-			if ( message_set_name == "errors" )
-			{
-				teleport_msg_map = &sTeleportErrorMessages;
-			}
-			else if ( message_set_name == "progress" )
-			{
-				teleport_msg_map = &sTeleportProgressMessages;
-			}
-		}
-
-		if ( !teleport_msg_map ) continue;
-
-		std::string message_name;
-		for (LLXMLNode* message_node = message_set->getFirstChild();
-			 message_node != NULL;
-			 message_node = message_node->getNextSibling())
-		{
-			if ( message_node->hasName("message") && 
-				 message_node->getAttributeString("name", message_name) )
-			{
-				(*teleport_msg_map)[message_name] =
-					message_node->getTextContents();
-			} //end if ( message exists and has a name)
-		} //end for (all message in set)
-	}//end for (all message sets in xml file)
-}
-
-const void LLAgent::getTeleportSourceSLURL(LLSLURL& slurl) const
-{
-	slurl = *mTeleportSourceSLURL;
-}
-
-// static
-void LLAgent::dumpGroupInfo()
-{
-	LL_INFOS() << "group   " << gAgent.mGroupName << LL_ENDL;
-	LL_INFOS() << "ID      " << gAgent.mGroupID << LL_ENDL;
-	LL_INFOS() << "powers " << gAgent.mGroupPowers << LL_ENDL;
-	LL_INFOS() << "title   " << gAgent.mGroupTitle << LL_ENDL;
-	//LL_INFOS() << "insig   " << gAgent.mGroupInsigniaID << LL_ENDL;
-}
-
-// Draw a representation of current autopilot target
-void LLAgent::renderAutoPilotTarget()
-{
-	if (mAutoPilot)
-	{
-		F32 height_meters;
-		LLVector3d target_global;
-
-		gGL.matrixMode(LLRender::MM_MODELVIEW);
-		gGL.pushMatrix();
-
-		// not textured
-		gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);
-
-		// lovely green
-		gGL.color4f(0.f, 1.f, 1.f, 1.f);
-
-		target_global = mAutoPilotTargetGlobal;
-
-		gGL.translatef((F32)(target_global.mdV[VX]), (F32)(target_global.mdV[VY]), (F32)(target_global.mdV[VZ]));
-
-		height_meters = 1.f;
-
-		gGL.scalef(height_meters, height_meters, height_meters);
-
-		gSphere.render();
-
-		gGL.popMatrix();
-	}
-}
-
-/********************************************************************************/
-
-//-----------------------------------------------------------------------------
-// LLTeleportRequest
-//-----------------------------------------------------------------------------
-
-LLTeleportRequest::LLTeleportRequest()
-	: mStatus(kPending)
-{
-}
-
-LLTeleportRequest::~LLTeleportRequest()
-{
-}
-
-bool LLTeleportRequest::canRestartTeleport()
-{
-	return false;
-}
-
-void LLTeleportRequest::restartTeleport()
-{
-	llassert(0);
-}
-
-// TODO this enum -> name idiom should be in a common class rather than repeated various places.
-const std::string& LLTeleportRequest::statusName(EStatus status)
-{
-	static std::string invalid_status_str("INVALID");
-	auto iter = LLTeleportRequest::sTeleportStatusName.find(status);
-	if (iter != LLTeleportRequest::sTeleportStatusName.end())
-	{
-		return iter->second;
-	}
-	else
-	{
-		return invalid_status_str;
-	}
-}
-
-std::ostream& operator<<(std::ostream& os, const LLTeleportRequest& req)
-{
-	req.toOstream(os);
-	return os;
-}
-
-void LLTeleportRequest::toOstream(std::ostream& os) const
-{
-	os << "status " << statusName(mStatus) << "(" << mStatus << ")";
-}
-
-//-----------------------------------------------------------------------------
-// LLTeleportRequestViaLandmark
-//-----------------------------------------------------------------------------
-LLTeleportRequestViaLandmark::LLTeleportRequestViaLandmark(const LLUUID &pLandmarkId)
-	: LLTeleportRequest(),
-	mLandmarkId(pLandmarkId)
-{
-    LL_INFOS("Teleport") << "LLTeleportRequestViaLandmark created, " << *this << LL_ENDL;
-}
-
-LLTeleportRequestViaLandmark::~LLTeleportRequestViaLandmark()
-{
-    LL_INFOS("Teleport") << "~LLTeleportRequestViaLandmark, " << *this << LL_ENDL;
-}
-
-void LLTeleportRequestViaLandmark::toOstream(std::ostream& os) const
-{
-	os << "landmark " << mLandmarkId << " ";
-	LLTeleportRequest::toOstream(os);
-}
-
-bool LLTeleportRequestViaLandmark::canRestartTeleport()
-{
-    LL_INFOS("Teleport") << "LLTeleportRequestViaLandmark::canRestartTeleport? -> true, " << *this << LL_ENDL;
-	return true;
-}
-
-void LLTeleportRequestViaLandmark::startTeleport()
-{
-    LL_INFOS("Teleport") << "LLTeleportRequestViaLandmark::startTeleport, " << *this << LL_ENDL;
-	gAgent.doTeleportViaLandmark(getLandmarkId());
-}
-
-void LLTeleportRequestViaLandmark::restartTeleport()
-{
-    LL_INFOS("Teleport") << "LLTeleportRequestViaLandmark::restartTeleport, " << *this << LL_ENDL;
-	gAgent.doTeleportViaLandmark(getLandmarkId());
-}
-//-----------------------------------------------------------------------------
-// LLTeleportRequestViaLure
-//-----------------------------------------------------------------------------
-
-LLTeleportRequestViaLure::LLTeleportRequestViaLure(const LLUUID &pLureId, bool pIsLureGodLike)
-	: LLTeleportRequestViaLandmark(pLureId),
-	mIsLureGodLike(pIsLureGodLike)
-{
-    LL_INFOS("Teleport") << "LLTeleportRequestViaLure created" << LL_ENDL;
-}
-
-LLTeleportRequestViaLure::~LLTeleportRequestViaLure()
-{
-    LL_INFOS("Teleport") << "~LLTeleportRequestViaLure" << LL_ENDL;
-}
-
-void LLTeleportRequestViaLure::toOstream(std::ostream& os) const
-{
-	os << "mIsLureGodLike " << (S32) mIsLureGodLike << " ";
-	LLTeleportRequestViaLandmark::toOstream(os);
-}
-
-bool LLTeleportRequestViaLure::canRestartTeleport()
-{
-	// stinson 05/17/2012 : cannot restart a teleport via lure because of server-side restrictions
-	// The current scenario is as follows:
-	//    1. User A initializes a request for User B to teleport via lure
-	//    2. User B accepts the teleport via lure request
-	//    3. The server sees the init request from User A and the accept request from User B and matches them up
-	//    4. The server then removes the paired requests up from the "queue"
-	//    5. The server then fails User B's teleport for reason of maturity level (for example)
-	//    6. User B's viewer prompts user to increase their maturity level profile value.
-	//    7. User B confirms and accepts increase in maturity level
-	//    8. User B's viewer then attempts to teleport via lure again
-	//    9. This request will time-out on the viewer-side because User A's initial request has been removed from the "queue" in step 4
-
-    LL_INFOS("Teleport") << "LLTeleportRequestViaLure::canRestartTeleport? -> false" << LL_ENDL;
-    return false;
-}
-
-void LLTeleportRequestViaLure::startTeleport()
-{
-    LL_INFOS("Teleport") << "LLTeleportRequestViaLure::startTeleport" << LL_ENDL;
-	gAgent.doTeleportViaLure(getLandmarkId(), isLureGodLike());
-}
-
-//-----------------------------------------------------------------------------
-// LLTeleportRequestViaLocation
-//-----------------------------------------------------------------------------
-
-LLTeleportRequestViaLocation::LLTeleportRequestViaLocation(const LLVector3d &pPosGlobal)
-	: LLTeleportRequest(),
-	mPosGlobal(pPosGlobal)
-{
-    LL_INFOS("Teleport") << "LLTeleportRequestViaLocation created" << LL_ENDL;
-}
-
-LLTeleportRequestViaLocation::~LLTeleportRequestViaLocation()
-{
-    LL_INFOS("Teleport") << "~LLTeleportRequestViaLocation" << LL_ENDL;
-}
-
-void LLTeleportRequestViaLocation::toOstream(std::ostream& os) const
-{
-	os << "mPosGlobal " << mPosGlobal << " ";
-	LLTeleportRequest::toOstream(os);
-}
-
-bool LLTeleportRequestViaLocation::canRestartTeleport()
-{
-    LL_INFOS("Teleport") << "LLTeleportRequestViaLocation::canRestartTeleport -> true" << LL_ENDL;
-	return true;
-}
-
-void LLTeleportRequestViaLocation::startTeleport()
-{
-    LL_INFOS("Teleport") << "LLTeleportRequestViaLocation::startTeleport" << LL_ENDL;
-	gAgent.doTeleportViaLocation(getPosGlobal());
-}
-
-void LLTeleportRequestViaLocation::restartTeleport()
-{
-    LL_INFOS("Teleport") << "LLTeleportRequestViaLocation::restartTeleport" << LL_ENDL;
-    gAgent.doTeleportViaLocation(getPosGlobal());
-}
-
-//-----------------------------------------------------------------------------
-// LLTeleportRequestViaLocationLookAt
-//-----------------------------------------------------------------------------
-
-LLTeleportRequestViaLocationLookAt::LLTeleportRequestViaLocationLookAt(const LLVector3d &pPosGlobal)
-	: LLTeleportRequestViaLocation(pPosGlobal)
-{
-    LL_INFOS("Teleport") << "LLTeleportRequestViaLocationLookAt created" << LL_ENDL;
-}
-
-LLTeleportRequestViaLocationLookAt::~LLTeleportRequestViaLocationLookAt()
-{
-    LL_INFOS("Teleport") << "~LLTeleportRequestViaLocationLookAt" << LL_ENDL;
-}
-
-void LLTeleportRequestViaLocationLookAt::toOstream(std::ostream& os) const
-{
-	LLTeleportRequestViaLocation::toOstream(os);
-}
-
-bool LLTeleportRequestViaLocationLookAt::canRestartTeleport()
-{
-    LL_INFOS("Teleport") << "LLTeleportRequestViaLocationLookAt::canRestartTeleport -> true" << LL_ENDL;
-    return true;
-}
-
-void LLTeleportRequestViaLocationLookAt::startTeleport()
-{
-    LL_INFOS("Teleport") << "LLTeleportRequestViaLocationLookAt::startTeleport" << LL_ENDL;
-    gAgent.doTeleportViaLocationLookAt(getPosGlobal());
-}
-
-void LLTeleportRequestViaLocationLookAt::restartTeleport()
-{
-    LL_INFOS("Teleport") << "LLTeleportRequestViaLocationLookAt::restartTeleport" << LL_ENDL;
-    gAgent.doTeleportViaLocationLookAt(getPosGlobal());
-}
-
-// EOF
+/**

+ * @file llagent.cpp

+ * @brief LLAgent class implementation

+ *

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

+ */

+

+

+#include "llviewerprecompiledheaders.h"

+

+#include "llagent.h"

+

+#include "pipeline.h"

+

+#include "llagentaccess.h"

+#include "llagentbenefits.h"

+#include "llagentcamera.h"

+#include "llagentlistener.h"

+#include "llagentwearables.h"

+#include "llagentui.h"

+#include "llappearancemgr.h"

+#include "llanimationstates.h"

+#include "llcallingcard.h"

+#include "llchannelmanager.h"

+#include "llchicletbar.h"

+#include "llconsole.h"

+#include "lldonotdisturbnotificationstorage.h"

+#include "llfirstuse.h"

+#include "llfloatercamera.h"

+#include "llfloaterimcontainer.h"

+#include "llfloaterperms.h"

+#include "llfloaterpreference.h"

+#include "llfloaterreg.h"

+#include "llfloatersnapshot.h"

+#include "llfloatertools.h"

+#include "llgroupactions.h"

+#include "llgroupmgr.h"

+#include "llhudmanager.h"

+#include "lljoystickbutton.h"

+#include "llmorphview.h"

+#include "llmoveview.h"

+#include "llnavigationbar.h" // to show/hide navigation bar when changing mouse look state

+#include "llfloaterimnearbychat.h"

+#include "llnotificationsutil.h"

+#include "llpaneltopinfobar.h"

+#include "llparcel.h"

+#include "llperfstats.h"

+#include "llrendersphere.h"

+#include "llscriptruntimeperms.h"

+#include "llsdutil.h"

+#include "llsky.h"

+#include "llslurl.h"

+#include "llsmoothstep.h"

+#include "llstartup.h"

+#include "llstatusbar.h"

+#include "llteleportflags.h"

+#include "lltool.h"

+#include "lltoolbarview.h"

+#include "lltoolpie.h"

+#include "lltoolmgr.h"

+#include "lltrans.h"

+#include "lluictrl.h"

+#include "llurlentry.h"

+#include "llviewercontrol.h"

+#include "llviewerdisplay.h"

+#include "llviewerjoystick.h"

+#include "llviewermediafocus.h"

+#include "llviewermenu.h"

+#include "llviewerobjectlist.h"

+#include "llviewerparcelmgr.h"

+#include "llviewerregion.h"

+#include "llviewerstats.h"

+#include "llviewerwindow.h"

+#include "llvoavatarself.h"

+#include "llwindow.h"

+#include "llworld.h"

+#include "llworldmap.h"

+#include "stringize.h"

+#include "llcorehttputil.h"

+#include "lluiusage.h"

+

+using namespace LLAvatarAppearanceDefines;

+

+extern LLMenuBarGL* gMenuBarView;

+

+const bool ANIMATE = true;

+const U8 AGENT_STATE_TYPING =   0x04;

+const U8 AGENT_STATE_EDITING =  0x10;

+

+// Autopilot constants

+const F32 AUTOPILOT_HEIGHT_ADJUST_DISTANCE = 8.f;           // meters

+const F32 AUTOPILOT_MIN_TARGET_HEIGHT_OFF_GROUND = 1.f; // meters

+const F32 AUTOPILOT_MAX_TIME_NO_PROGRESS_WALK = 1.5f;       // seconds

+const F32 AUTOPILOT_MAX_TIME_NO_PROGRESS_FLY = 2.5f;        // seconds. Flying is less presize, needs a bit more time

+

+const F32 MAX_VELOCITY_AUTO_LAND_SQUARED = 4.f * 4.f;

+const F64 CHAT_AGE_FAST_RATE = 3.0;

+

+// fidget constants

+const F32 MIN_FIDGET_TIME = 8.f; // seconds

+const F32 MAX_FIDGET_TIME = 20.f; // seconds

+

+const S32 UI_FEATURE_VERSION = 1;

+// For version 1: 1 - inventory, 2 - gltf

+const S32 UI_FEATURE_FLAGS = 3;

+

+// The agent instance.

+LLAgent gAgent;

+

+class LLTeleportRequest

+{

+public:

+    enum EStatus

+    {

+        kPending,

+        kStarted,

+        kFailed,

+        kRestartPending

+    };

+

+    LLTeleportRequest();

+    virtual ~LLTeleportRequest();

+

+    EStatus getStatus() const          {return mStatus;};

+    void    setStatus(EStatus pStatus) {mStatus = pStatus;};

+

+    static std::map<S32, std::string> sTeleportStatusName;

+    static const std::string& statusName(EStatus status);

+    virtual void toOstream(std::ostream& os) const;

+

+    virtual bool canRestartTeleport();

+

+    virtual void startTeleport() = 0;

+    virtual void restartTeleport();

+

+protected:

+

+private:

+    EStatus mStatus;

+};

+

+std::map<S32, std::string> LLTeleportRequest::sTeleportStatusName = { { kPending, "kPending" },

+                                                                      { kStarted, "kStarted" },

+                                                                      { kFailed, "kFailed" },

+                                                                      { kRestartPending, "kRestartPending"} };

+

+class LLTeleportRequestViaLandmark : public LLTeleportRequest

+{

+public:

+    LLTeleportRequestViaLandmark(const LLUUID &pLandmarkId);

+    virtual ~LLTeleportRequestViaLandmark();

+

+    virtual void toOstream(std::ostream& os) const;

+

+    virtual bool canRestartTeleport();

+

+    virtual void startTeleport();

+    virtual void restartTeleport();

+

+protected:

+    inline const LLUUID &getLandmarkId() const {return mLandmarkId;};

+

+private:

+    LLUUID mLandmarkId;

+};

+

+class LLTeleportRequestViaLure : public LLTeleportRequestViaLandmark

+{

+public:

+    LLTeleportRequestViaLure(const LLUUID &pLureId, bool pIsLureGodLike);

+    virtual ~LLTeleportRequestViaLure();

+

+    virtual void toOstream(std::ostream& os) const;

+

+    virtual bool canRestartTeleport();

+

+    virtual void startTeleport();

+

+protected:

+    inline bool isLureGodLike() const {return mIsLureGodLike;};

+

+private:

+    bool mIsLureGodLike;

+};

+

+class LLTeleportRequestViaLocation : public LLTeleportRequest

+{

+public:

+    LLTeleportRequestViaLocation(const LLVector3d &pPosGlobal);

+    virtual ~LLTeleportRequestViaLocation();

+

+    virtual void toOstream(std::ostream& os) const;

+

+    virtual bool canRestartTeleport();

+

+    virtual void startTeleport();

+    virtual void restartTeleport();

+

+protected:

+    inline const LLVector3d &getPosGlobal() const {return mPosGlobal;};

+

+private:

+    LLVector3d mPosGlobal;

+};

+

+

+class LLTeleportRequestViaLocationLookAt : public LLTeleportRequestViaLocation

+{

+public:

+    LLTeleportRequestViaLocationLookAt(const LLVector3d &pPosGlobal);

+    virtual ~LLTeleportRequestViaLocationLookAt();

+

+    virtual void toOstream(std::ostream& os) const;

+

+    virtual bool canRestartTeleport();

+

+    virtual void startTeleport();

+    virtual void restartTeleport();

+

+protected:

+

+private:

+

+};

+

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

+// Statics

+//

+

+/// minimum time after setting away state before coming back based on movement

+const F32 LLAgent::MIN_AFK_TIME = 10.0f;

+

+const F32 LLAgent::TYPING_TIMEOUT_SECS = 5.f;

+

+std::map<std::string, std::string> LLAgent::sTeleportErrorMessages;

+std::map<std::string, std::string> LLAgent::sTeleportProgressMessages;

+

+class LLAgentFriendObserver : public LLFriendObserver

+{

+public:

+    LLAgentFriendObserver() {}

+    virtual ~LLAgentFriendObserver() {}

+    virtual void changed(U32 mask);

+};

+

+void LLAgentFriendObserver::changed(U32 mask)

+{

+    // if there's a change we're interested in.

+    if((mask & (LLFriendObserver::POWERS)) != 0)

+    {

+        gAgent.friendsChanged();

+    }

+}

+

+bool handleSlowMotionAnimation(const LLSD& newvalue)

+{

+    if (newvalue.asBoolean())

+    {

+        gAgentAvatarp->setAnimTimeFactor(0.2f);

+    }

+    else

+    {

+        gAgentAvatarp->setAnimTimeFactor(1.0f);

+    }

+    return true;

+}

+

+void LLAgent::setCanEditParcel() // called via mParcelChangedSignal

+{

+    bool can_edit = LLToolMgr::getInstance()->canEdit();

+    gAgent.mCanEditParcel = can_edit;

+}

+

+// static

+bool LLAgent::isActionAllowed(const LLSD& sdname)

+{

+    bool retval = false;

+

+    const std::string& param = sdname.asString();

+

+    if (param == "speak")

+    {

+        bool allow_agent_voice = false;

+        LLVoiceChannel* channel = LLVoiceChannel::getCurrentVoiceChannel();

+        if (channel != NULL)

+        {

+            if (channel->getSessionName().empty() && channel->getSessionID().isNull())

+            {

+                // default channel

+                allow_agent_voice = LLViewerParcelMgr::getInstance()->allowAgentVoice();

+            }

+            else

+            {

+                allow_agent_voice = channel->isActive() && channel->callStarted();

+            }

+        }

+

+        if (gAgent.isVoiceConnected() &&

+            allow_agent_voice &&

+            !LLVoiceClient::getInstance()->inTuningMode())

+        {

+            retval = true;

+        }

+        else

+        {

+            retval = false;

+        }

+    }

+

+    return retval;

+}

+

+// static

+void LLAgent::pressMicrophone(const LLSD& name)

+{

+    LLFirstUse::speak(false);

+

+     LLVoiceClient::getInstance()->inputUserControlState(true);

+}

+

+// static

+void LLAgent::releaseMicrophone(const LLSD& name)

+{

+    LLVoiceClient::getInstance()->inputUserControlState(false);

+}

+

+// static

+void LLAgent::toggleMicrophone(const LLSD& name)

+{

+    LLVoiceClient::getInstance()->toggleUserPTTState();

+}

+

+// static

+bool LLAgent::isMicrophoneOn(const LLSD& sdname)

+{

+    return LLVoiceClient::getInstance()->getUserPTTState();

+}

+

+// ************************************************************

+// Enabled this definition to compile a 'hacked' viewer that

+// locally believes the end user has godlike powers.

+// #define HACKED_GODLIKE_VIEWER

+// For a toggled version, see viewer.h for the

+// TOGGLE_HACKED_GODLIKE_VIEWER define, instead.

+// ************************************************************

+

+// Constructors and Destructors

+

+// JC - Please try to make this order match the order in the header

+// file.  Otherwise it's hard to find variables that aren't initialized.

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

+// LLAgent()

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

+LLAgent::LLAgent() :

+    mGroupPowers(0),

+    mHideGroupTitle(false),

+    mGroupID(),

+

+    mInitialized(false),

+    mListener(),

+

+    mDoubleTapRunTimer(),

+    mDoubleTapRunMode(DOUBLETAP_NONE),

+

+    mbAlwaysRun(false),

+    mbRunning(false),

+    mbTeleportKeepsLookAt(false),

+

+    mAgentAccess(new LLAgentAccess(gSavedSettings)),

+    mGodLevelChangeSignal(),

+    mCanEditParcel(false),

+    mTeleportSourceSLURL(new LLSLURL),

+    mTeleportRequest(),

+    mTeleportFinishedSlot(),

+    mTeleportFailedSlot(),

+    mIsMaturityRatingChangingDuringTeleport(false),

+    mTPNeedsNeabyChatSeparator(false),

+    mMaturityRatingChange(0U),

+    mIsDoSendMaturityPreferenceToServer(false),

+    mMaturityPreferenceRequestId(0U),

+    mMaturityPreferenceResponseId(0U),

+    mMaturityPreferenceNumRetries(0U),

+    mLastKnownRequestMaturity(SIM_ACCESS_MIN),

+    mLastKnownResponseMaturity(SIM_ACCESS_MIN),

+    mHttpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID),

+    mTeleportState(TELEPORT_NONE),

+    mRegionp(NULL),

+    mInterestListMode(IL_MODE_DEFAULT),

+

+    mAgentOriginGlobal(),

+    mPositionGlobal(),

+    mLastTestGlobal(),

+

+    mDistanceTraveled(0.F),

+    mLastPositionGlobal(LLVector3d::zero),

+

+    mRenderState(0),

+    mTypingTimer(),

+

+    mViewsPushed(false),

+

+    mCustomAnim(false),

+    mShowAvatar(true),

+    mFrameAgent(),

+

+    mIsDoNotDisturb(false),

+

+    mControlFlags(0x00000000),

+    mbFlagsDirty(false),

+    mbFlagsNeedReset(false),

+

+    mAutoPilot(false),

+    mAutoPilotFlyOnStop(false),

+    mAutoPilotAllowFlying(true),

+    mAutoPilotTargetGlobal(),

+    mAutoPilotStopDistance(1.f),

+    mAutoPilotUseRotation(false),

+    mAutoPilotTargetFacing(LLVector3::zero),

+    mAutoPilotTargetDist(0.f),

+    mAutoPilotNoProgressFrameCount(0),

+    mAutoPilotRotationThreshold(0.f),

+    mAutoPilotFinishedCallback(NULL),

+    mAutoPilotCallbackData(NULL),

+

+    mMovementKeysLocked(false),

+

+    mEffectColor(new LLUIColor(LLColor4(0.f, 1.f, 1.f, 1.f))),

+

+    mHaveHomePosition(false),

+    mHomeRegionHandle( 0 ),

+    mNearChatRadius(CHAT_NORMAL_RADIUS / 2.f),

+

+    mNextFidgetTime(0.f),

+    mCurrentFidget(0),

+    mFirstLogin(false),

+    mOutfitChosen(false),

+

+    mVoiceConnected(false),

+

+    mMouselookModeInSignal(NULL),

+    mMouselookModeOutSignal(NULL)

+{

+    for (U32 i = 0; i < TOTAL_CONTROLS; i++)

+    {

+        mControlsTakenCount[i] = 0;

+        mControlsTakenPassedOnCount[i] = 0;

+    }

+

+    mListener.reset(new LLAgentListener(*this));

+

+    addParcelChangedCallback(&setCanEditParcel);

+

+    mMoveTimer.stop();

+}

+

+// Requires gSavedSettings to be initialized.

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

+// init()

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

+void LLAgent::init()

+{

+    mMoveTimer.start();

+

+    gSavedSettings.declareBOOL("SlowMotionAnimation", false, "Declared in code", LLControlVariable::PERSIST_NO);

+    gSavedSettings.getControl("SlowMotionAnimation")->getSignal()->connect(boost::bind(&handleSlowMotionAnimation, _2));

+

+    // *Note: this is where LLViewerCamera::getInstance() used to be constructed.

+

+    bool is_flying = gSavedSettings.getBOOL("FlyingAtExit");

+    if(is_flying)

+    {

+        setFlying(is_flying);

+    }

+

+    *mEffectColor = LLUIColorTable::instance().getColor("EffectColor");

+

+    gSavedSettings.getControl("PreferredMaturity")->getValidateSignal()->connect(boost::bind(&LLAgent::validateMaturity, this, _2));

+    gSavedSettings.getControl("PreferredMaturity")->getSignal()->connect(boost::bind(&LLAgent::handleMaturity, this, _2));

+    mLastKnownResponseMaturity = static_cast<U8>(gSavedSettings.getU32("PreferredMaturity"));

+    mLastKnownRequestMaturity = mLastKnownResponseMaturity;

+    mIsDoSendMaturityPreferenceToServer = true;

+

+    if (!mTeleportFinishedSlot.connected())

+    {

+        mTeleportFinishedSlot = LLViewerParcelMgr::getInstance()->setTeleportFinishedCallback(boost::bind(&LLAgent::handleTeleportFinished, this));

+    }

+    if (!mTeleportFailedSlot.connected())

+    {

+        mTeleportFailedSlot = LLViewerParcelMgr::getInstance()->setTeleportFailedCallback(boost::bind(&LLAgent::handleTeleportFailed, this));

+    }

+

+    LLAppCoreHttp & app_core_http(LLAppViewer::instance()->getAppCoreHttp());

+

+    mHttpPolicy = app_core_http.getPolicy(LLAppCoreHttp::AP_AGENT);

+

+    mInitialized = true;

+}

+

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

+// cleanup()

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

+void LLAgent::cleanup()

+{

+    mRegionp = NULL;

+    mTeleportRequest = NULL;

+    mTeleportCanceled = NULL;

+    if (mTeleportFinishedSlot.connected())

+    {

+        mTeleportFinishedSlot.disconnect();

+    }

+    if (mTeleportFailedSlot.connected())

+    {

+        mTeleportFailedSlot.disconnect();

+    }

+}

+

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

+// LLAgent()

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

+LLAgent::~LLAgent()

+{

+    cleanup();

+

+    delete mMouselookModeInSignal;

+    mMouselookModeInSignal = NULL;

+    delete mMouselookModeOutSignal;

+    mMouselookModeOutSignal = NULL;

+

+    delete mAgentAccess;

+    mAgentAccess = NULL;

+    delete mEffectColor;

+    mEffectColor = NULL;

+    delete mTeleportSourceSLURL;

+    mTeleportSourceSLURL = NULL;

+}

+

+// Handle any actions that need to be performed when the main app gains focus

+// (such as through alt-tab).

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

+// onAppFocusGained()

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

+void LLAgent::onAppFocusGained()

+{

+    if (CAMERA_MODE_MOUSELOOK == gAgentCamera.getCameraMode())

+    {

+        gAgentCamera.changeCameraToDefault();

+        LLToolMgr::getInstance()->clearSavedTool();

+    }

+}

+

+void LLAgent::setFirstLogin(bool b)

+{

+    mFirstLogin = b;

+

+    if (mFirstLogin)

+    {

+        // Don't notify new users about new features

+        if (getFeatureVersion() <= UI_FEATURE_VERSION)

+        {

+            setFeatureVersion(UI_FEATURE_VERSION, UI_FEATURE_FLAGS);

+        }

+    }

+}

+

+void LLAgent::setFeatureVersion(S32 version, S32 flags)

+{

+    LLSD updated_version;

+    updated_version["version"] = version;

+    updated_version["flags"] = flags;

+    gSavedSettings.setLLSD("LastUIFeatureVersion", updated_version);

+}

+

+S32 LLAgent::getFeatureVersion()

+{

+    S32 version;

+    S32 flags;

+    getFeatureVersionAndFlags(version, flags);

+    return version;

+}

+

+void LLAgent::getFeatureVersionAndFlags(S32& version, S32& flags)

+{

+    version = 0;

+    flags = 0;

+    LLSD feature_version = gSavedSettings.getLLSD("LastUIFeatureVersion");

+    if (feature_version.isInteger())

+    {

+        version = feature_version.asInteger();

+        flags = 1; // inventory flag

+    }

+    else if (feature_version.isMap())

+    {

+        version = feature_version["version"];

+        flags = feature_version["flags"];

+    }

+    else if (!feature_version.isString() && !feature_version.isUndefined())

+    {

+        // is something newer inside?

+        version = UI_FEATURE_VERSION;

+        flags = UI_FEATURE_FLAGS;

+    }

+}

+

+void LLAgent::showLatestFeatureNotification(const std::string key)

+{

+    S32 version;

+    S32 flags; // a single release can have multiple new features

+    getFeatureVersionAndFlags(version, flags);

+    if (version <= UI_FEATURE_VERSION && (flags & UI_FEATURE_FLAGS) != UI_FEATURE_FLAGS)

+    {

+        S32 flag = 0;

+

+        if (key == "inventory")

+        {

+            // Notify user about new thumbnail support

+            flag = 1;

+        }

+

+        if (key == "gltf")

+        {

+            flag = 2;

+        }

+

+        if ((flags & flag) == 0)

+        {

+            // Need to open on top even if called from onOpen,

+            // do on idle to make sure it's on top

+            LLSD floater_key(key);

+            doOnIdleOneTime([floater_key]()

+                            {

+                                LLFloaterReg::showInstance("new_feature_notification", floater_key);

+                            });

+

+            setFeatureVersion(UI_FEATURE_VERSION, flags | flag);

+        }

+    }

+}

+

+void LLAgent::ageChat()

+{

+    if (isAgentAvatarValid())

+    {

+        // get amount of time since I last chatted

+        F64 elapsed_time = (F64)gAgentAvatarp->mChatTimer.getElapsedTimeF32();

+        // add in frame time * 3 (so it ages 4x)

+        gAgentAvatarp->mChatTimer.setAge(elapsed_time + (F64)gFrameDTClamped * (CHAT_AGE_FAST_RATE - 1.0));

+    }

+}

+

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

+// moveAt()

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

+void LLAgent::moveAt(S32 direction, bool reset)

+{

+    LLUIUsage::instance().logCommand("Agent.MoveAt");

+

+    mMoveTimer.reset();

+    LLFirstUse::notMoving(false);

+

+    // age chat timer so it fades more quickly when you are intentionally moving

+    ageChat();

+

+    gAgentCamera.setAtKey(LLAgentCamera::directionToKey(direction));

+

+    if (direction > 0)

+    {

+        setControlFlags(AGENT_CONTROL_AT_POS | AGENT_CONTROL_FAST_AT);

+    }

+    else if (direction < 0)

+    {

+        setControlFlags(AGENT_CONTROL_AT_NEG | AGENT_CONTROL_FAST_AT);

+    }

+

+    if (reset)

+    {

+        gAgentCamera.resetView();

+    }

+}

+

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

+// moveAtNudge()

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

+void LLAgent::moveAtNudge(S32 direction)

+{

+    mMoveTimer.reset();

+    LLFirstUse::notMoving(false);

+

+    // age chat timer so it fades more quickly when you are intentionally moving

+    ageChat();

+

+    gAgentCamera.setWalkKey(LLAgentCamera::directionToKey(direction));

+

+    if (direction > 0)

+    {

+        setControlFlags(AGENT_CONTROL_NUDGE_AT_POS);

+    }

+    else if (direction < 0)

+    {

+        setControlFlags(AGENT_CONTROL_NUDGE_AT_NEG);

+    }

+

+    gAgentCamera.resetView();

+}

+

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

+// moveLeft()

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

+void LLAgent::moveLeft(S32 direction)

+{

+    mMoveTimer.reset();

+    LLFirstUse::notMoving(false);

+

+    // age chat timer so it fades more quickly when you are intentionally moving

+    ageChat();

+

+    gAgentCamera.setLeftKey(LLAgentCamera::directionToKey(direction));

+

+    if (direction > 0)

+    {

+        setControlFlags(AGENT_CONTROL_LEFT_POS | AGENT_CONTROL_FAST_LEFT);

+    }

+    else if (direction < 0)

+    {

+        setControlFlags(AGENT_CONTROL_LEFT_NEG | AGENT_CONTROL_FAST_LEFT);

+    }

+

+    gAgentCamera.resetView();

+}

+

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

+// moveLeftNudge()

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

+void LLAgent::moveLeftNudge(S32 direction)

+{

+    mMoveTimer.reset();

+    LLFirstUse::notMoving(false);

+

+    // age chat timer so it fades more quickly when you are intentionally moving

+    ageChat();

+

+    gAgentCamera.setLeftKey(LLAgentCamera::directionToKey(direction));

+

+    if (direction > 0)

+    {

+        setControlFlags(AGENT_CONTROL_NUDGE_LEFT_POS);

+    }

+    else if (direction < 0)

+    {

+        setControlFlags(AGENT_CONTROL_NUDGE_LEFT_NEG);

+    }

+

+    gAgentCamera.resetView();

+}

+

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

+// moveUp()

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

+void LLAgent::moveUp(S32 direction)

+{

+    mMoveTimer.reset();

+    LLFirstUse::notMoving(false);

+

+    // age chat timer so it fades more quickly when you are intentionally moving

+    ageChat();

+

+    gAgentCamera.setUpKey(LLAgentCamera::directionToKey(direction));

+

+    if (direction > 0)

+    {

+        setControlFlags(AGENT_CONTROL_UP_POS | AGENT_CONTROL_FAST_UP);

+    }

+    else if (direction < 0)

+    {

+        setControlFlags(AGENT_CONTROL_UP_NEG | AGENT_CONTROL_FAST_UP);

+    }

+

+    gAgentCamera.resetView();

+}

+

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

+// moveYaw()

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

+void LLAgent::moveYaw(F32 mag, bool reset_view)

+{

+    gAgentCamera.setYawKey(mag);

+

+    if (mag > 0)

+    {

+        setControlFlags(AGENT_CONTROL_YAW_POS);

+    }

+    else if (mag < 0)

+    {

+        setControlFlags(AGENT_CONTROL_YAW_NEG);

+    }

+

+    U32 mask = AGENT_CONTROL_YAW_POS | AGENT_CONTROL_YAW_NEG;

+    if ((getControlFlags() & mask) == mask)

+    {

+        // Rotation into both directions should cancel out

+        // But keep sending controls to simulator,

+        // it's needed for script based controls

+        gAgentCamera.setYawKey(0);

+    }

+

+    if (reset_view)

+    {

+        gAgentCamera.resetView();

+    }

+}

+

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

+// movePitch()

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

+void LLAgent::movePitch(F32 mag)

+{

+    gAgentCamera.setPitchKey(mag);

+

+    if (mag > 0)

+    {

+        setControlFlags(AGENT_CONTROL_PITCH_POS);

+    }

+    else if (mag < 0)

+    {

+        setControlFlags(AGENT_CONTROL_PITCH_NEG);

+    }

+}

+

+

+// Does this parcel allow you to fly?

+bool LLAgent::canFly()

+{

+    if (isGodlike()) return true;

+

+    LLViewerRegion* regionp = getRegion();

+    if (regionp && regionp->getBlockFly()) return false;

+

+    LLParcel* parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();

+    if (!parcel) return false;

+

+    // Allow owners to fly on their own land.

+    if (LLViewerParcelMgr::isParcelOwnedByAgent(parcel, GP_LAND_ALLOW_FLY))

+    {

+        return true;

+    }

+

+    return parcel->getAllowFly();

+}

+

+bool LLAgent::getFlying() const

+{

+    return mControlFlags & AGENT_CONTROL_FLY;

+}

+

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

+// setFlying()

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

+void LLAgent::setFlying(bool fly, bool fail_sound)

+{

+    if (isAgentAvatarValid())

+    {

+        // *HACK: Don't allow to start the flying mode if we got ANIM_AGENT_STANDUP signal

+        // because in this case we won't get a signal to start avatar flying animation and

+        // it will be walking with flying mode "ON" indication. However we allow to switch

+        // the flying mode off if we get ANIM_AGENT_STANDUP signal. See process_avatar_animation().

+        // See EXT-2781.

+        if(fly && gAgentAvatarp->mSignaledAnimations.find(ANIM_AGENT_STANDUP) != gAgentAvatarp->mSignaledAnimations.end())

+        {

+            return;

+        }

+

+        // don't allow taking off while sitting

+        if (fly && gAgentAvatarp->isSitting())

+        {

+            return;

+        }

+    }

+

+    if (fly)

+    {

+        bool was_flying = getFlying();

+        if (!canFly() && !was_flying)

+        {

+            // parcel doesn't let you start fly

+            // gods can always fly

+            // and it's OK if you're already flying

+            if (fail_sound)

+            {

+            make_ui_sound("UISndBadKeystroke");

+            }

+            return;

+        }

+        if( !was_flying )

+        {

+            add(LLStatViewer::FLY, 1);

+        }

+        setControlFlags(AGENT_CONTROL_FLY);

+    }

+    else

+    {

+        clearControlFlags(AGENT_CONTROL_FLY);

+    }

+

+

+    // Update Movement Controls according to Fly mode

+    LLFloaterMove::setFlyingMode(fly);

+

+    mbFlagsDirty = true;

+}

+

+

+// UI based mechanism of setting fly state

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

+// toggleFlying()

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

+// static

+void LLAgent::toggleFlying()

+{

+    if ( gAgent.mAutoPilot )

+    {

+        LLToolPie::instance().stopClickToWalk();

+    }

+

+    bool fly = !gAgent.getFlying();

+

+    gAgent.mMoveTimer.reset();

+    LLFirstUse::notMoving(false);

+

+    gAgent.setFlying( fly );

+    gAgentCamera.resetView();

+}

+

+// static

+bool LLAgent::enableFlying()

+{

+    bool sitting = false;

+    if (isAgentAvatarValid())

+    {

+        sitting = gAgentAvatarp->isSitting();

+    }

+    return !sitting;

+}

+

+// static

+bool LLAgent::isSitting()

+{

+    bool sitting = false;

+    if (isAgentAvatarValid())

+    {

+        sitting = gAgentAvatarp->isSitting();

+    }

+    return sitting;

+}

+

+void LLAgent::standUp()

+{

+    setControlFlags(AGENT_CONTROL_STAND_UP);

+}

+

+void LLAgent::changeParcels()

+{

+    LL_DEBUGS("AgentLocation") << "Calling ParcelChanged callbacks" << LL_ENDL;

+    // Notify anything that wants to know about parcel changes

+    mParcelChangedSignal();

+}

+

+boost::signals2::connection LLAgent::addParcelChangedCallback(parcel_changed_callback_t cb)

+{

+    return mParcelChangedSignal.connect(cb);

+}

+

+// static

+void LLAgent::capabilityReceivedCallback(const LLUUID &region_id, LLViewerRegion *regionp)

+{   // Changed regions and now have the region capabilities

+    if (regionp)

+    {

+        if (regionp->getRegionID() == region_id)

+        {

+            regionp->requestSimulatorFeatures();

+            LLAppViewer::instance()->updateNameLookupUrl(regionp);

+        }

+

+        if (gAgent.getInterestListMode() == IL_MODE_360)

+        {

+            gAgent.changeInterestListMode(IL_MODE_360);

+        }

+    }

+}

+

+

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

+// setRegion()

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

+void LLAgent::setRegion(LLViewerRegion *regionp)

+{

+    llassert(regionp);

+    if (mRegionp != regionp)

+    {

+

+        LL_INFOS("AgentLocation","Teleport") << "Moving agent into region: handle " << regionp->getHandle()

+                                             << " id " << regionp->getRegionID()

+                                             << " name " << regionp->getName()

+                                             << " previous region "

+                                             << (mRegionp ? mRegionp->getRegionID() : LLUUID::null)

+                                             << LL_ENDL;

+        if (mRegionp)

+        {

+            // We've changed regions, we're now going to change our agent coordinate frame.

+            mAgentOriginGlobal = regionp->getOriginGlobal();

+            LLVector3d agent_offset_global = mRegionp->getOriginGlobal();

+

+            LLVector3 delta;

+            delta.setVec(regionp->getOriginGlobal() - mRegionp->getOriginGlobal());

+

+            setPositionAgent(getPositionAgent() - delta);

+

+            LLVector3 camera_position_agent = LLViewerCamera::getInstance()->getOrigin();

+            LLViewerCamera::getInstance()->setOrigin(camera_position_agent - delta);

+

+            // Update all of the regions.

+            LLWorld::getInstance()->updateAgentOffset(agent_offset_global);

+

+            // Hack to keep sky in the agent's region, otherwise it may get deleted - DJS 08/02/02

+            // *TODO: possibly refactor into gSky->setAgentRegion(regionp)? -Brad

+            if (gSky.mVOSkyp)

+            {

+                gSky.mVOSkyp->setRegion(regionp);

+            }

+

+            if (regionp->capabilitiesReceived())

+            {

+                regionp->requestSimulatorFeatures();

+                LLAppViewer::instance()->updateNameLookupUrl(regionp);

+            }

+            else

+            {

+                regionp->setCapabilitiesReceivedCallback(LLAgent::capabilityReceivedCallback);

+            }

+

+        }

+        else

+        {

+            // First time initialization.

+            // We've changed regions, we're now going to change our agent coordinate frame.

+            mAgentOriginGlobal = regionp->getOriginGlobal();

+

+            LLVector3 delta;

+            delta.setVec(regionp->getOriginGlobal());

+

+            setPositionAgent(getPositionAgent() - delta);

+            LLVector3 camera_position_agent = LLViewerCamera::getInstance()->getOrigin();

+            LLViewerCamera::getInstance()->setOrigin(camera_position_agent - delta);

+

+            // Update all of the regions.

+            LLWorld::getInstance()->updateAgentOffset(mAgentOriginGlobal);

+

+            if (regionp->capabilitiesReceived())

+            {

+                LLAppViewer::instance()->updateNameLookupUrl(regionp);

+            }

+            else

+            {

+                regionp->setCapabilitiesReceivedCallback([](const LLUUID &region_id, LLViewerRegion* regionp) {LLAppViewer::instance()->updateNameLookupUrl(regionp); });

+            }

+        }

+

+        // Pass new region along to metrics components that care about this level of detail.

+        LLAppViewer::metricsUpdateRegion(regionp->getHandle());

+    }

+

+    mRegionp = regionp;

+

+    // TODO - most of what follows probably should be moved into callbacks

+

+    // Pass the region host to LLUrlEntryParcel to resolve parcel name

+    // with a server request.

+    LLUrlEntryParcel::setRegionHost(getRegionHost());

+

+    // Must shift hole-covering water object locations because local

+    // coordinate frame changed.

+    LLWorld::getInstance()->updateWaterObjects();

+

+    // keep a list of regions we've been too

+    // this is just an interesting stat, logged at the dataserver

+    // we could trake this at the dataserver side, but that's harder

+    U64 handle = regionp->getHandle();

+    mRegionsVisited.insert(handle);

+

+    LLSelectMgr::getInstance()->updateSelectionCenter();

+

+    LLFloaterMove::sUpdateFlyingStatus();

+

+    LL_DEBUGS("AgentLocation") << "Calling RegionChanged callbacks" << LL_ENDL;

+    mRegionChangedSignal();

+}

+

+

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

+// getRegion()

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

+LLViewerRegion *LLAgent::getRegion() const

+{

+    return mRegionp;

+}

+

+

+LLHost LLAgent::getRegionHost() const

+{

+    if (mRegionp)

+    {

+        return mRegionp->getHost();

+    }

+    else

+    {

+        return LLHost();

+    }

+}

+

+boost::signals2::connection LLAgent::addRegionChangedCallback(const region_changed_signal_t::slot_type& cb)

+{

+    return mRegionChangedSignal.connect(cb);

+}

+

+void LLAgent::removeRegionChangedCallback(boost::signals2::connection callback)

+{

+    mRegionChangedSignal.disconnect(callback);

+}

+

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

+// inPrelude()

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

+bool LLAgent::inPrelude()

+{

+    return mRegionp && mRegionp->isPrelude();

+}

+

+

+std::string LLAgent::getRegionCapability(const std::string &name)

+{

+    if (!mRegionp)

+        return std::string();

+

+    return mRegionp->getCapability(name);

+}

+

+

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

+// canManageEstate()

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

+

+bool LLAgent::canManageEstate() const

+{

+    return mRegionp && mRegionp->canManageEstate();

+}

+

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

+// sendMessage()

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

+void LLAgent::sendMessage()

+{

+    if (gDisconnected)

+    {

+        LL_WARNS() << "Trying to send message when disconnected!" << LL_ENDL;

+        return;

+    }

+    if (!mRegionp)

+    {

+        LL_ERRS() << "No region for agent yet!" << LL_ENDL;

+        return;

+    }

+    gMessageSystem->sendMessage(mRegionp->getHost());

+}

+

+

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

+// sendReliableMessage()

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

+void LLAgent::sendReliableMessage()

+{

+    if (gDisconnected)

+    {

+        LL_DEBUGS() << "Trying to send message when disconnected!" << LL_ENDL;

+        return;

+    }

+    if (!mRegionp)

+    {

+        LL_DEBUGS() << "LLAgent::sendReliableMessage No region for agent yet, not sending message!" << LL_ENDL;

+        return;

+    }

+    gMessageSystem->sendReliable(mRegionp->getHost());

+}

+

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

+// getVelocity()

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

+LLVector3 LLAgent::getVelocity() const

+{

+    if (isAgentAvatarValid())

+    {

+        return gAgentAvatarp->getVelocity();

+    }

+    else

+    {

+        return LLVector3::zero;

+    }

+}

+

+

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

+// setPositionAgent()

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

+void LLAgent::setPositionAgent(const LLVector3 &pos_agent)

+{

+    if (!pos_agent.isFinite())

+    {

+        LL_ERRS() << "setPositionAgent is not a number" << LL_ENDL;

+    }

+

+    if (isAgentAvatarValid() && gAgentAvatarp->getParent())

+    {

+        LLVector3 pos_agent_sitting;

+        LLVector3d pos_agent_d;

+        LLViewerObject *parent = (LLViewerObject*)gAgentAvatarp->getParent();

+

+        pos_agent_sitting = gAgentAvatarp->getPosition() * parent->getRotation() + parent->getPositionAgent();

+        pos_agent_d.setVec(pos_agent_sitting);

+

+        mFrameAgent.setOrigin(pos_agent_sitting);

+        mPositionGlobal = pos_agent_d + mAgentOriginGlobal;

+    }

+    else

+    {

+        mFrameAgent.setOrigin(pos_agent);

+

+        LLVector3d pos_agent_d;

+        pos_agent_d.setVec(pos_agent);

+        mPositionGlobal = pos_agent_d + mAgentOriginGlobal;

+    }

+

+    if (((mLastTestGlobal - mPositionGlobal).lengthSquared() > 1.0) && !mOnPositionChanged.empty())

+    {   // If the position has changed my more than 1 meter since the last time we triggered.

+        // filters out some noise.

+        mLastTestGlobal = mPositionGlobal;

+        mOnPositionChanged(mFrameAgent.getOrigin(), mPositionGlobal);

+    }

+}

+

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

+// getPositionGlobal()

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

+const LLVector3d &LLAgent::getPositionGlobal() const

+{

+    if (isAgentAvatarValid() && !gAgentAvatarp->mDrawable.isNull())

+    {

+        mPositionGlobal = getPosGlobalFromAgent(gAgentAvatarp->getRenderPosition());

+    }

+    else

+    {

+        mPositionGlobal = getPosGlobalFromAgent(mFrameAgent.getOrigin());

+    }

+

+    return mPositionGlobal;

+}

+

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

+// getPositionAgent()

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

+const LLVector3 &LLAgent::getPositionAgent()

+{

+    if (isAgentAvatarValid())

+    {

+        if(gAgentAvatarp->mDrawable.isNull())

+        {

+            mFrameAgent.setOrigin(gAgentAvatarp->getPositionAgent());

+        }

+        else

+    {

+        mFrameAgent.setOrigin(gAgentAvatarp->getRenderPosition());

+    }

+    }

+

+

+    return mFrameAgent.getOrigin();

+}

+

+boost::signals2::connection LLAgent::whenPositionChanged(position_signal_t::slot_type fn)

+{

+    return mOnPositionChanged.connect(fn);

+}

+

+

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

+// getRegionsVisited()

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

+S32 LLAgent::getRegionsVisited() const

+{

+    return mRegionsVisited.size();

+}

+

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

+// getDistanceTraveled()

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

+F64 LLAgent::getDistanceTraveled() const

+{

+    return mDistanceTraveled;

+}

+

+

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

+// getPosAgentFromGlobal()

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

+LLVector3 LLAgent::getPosAgentFromGlobal(const LLVector3d &pos_global) const

+{

+    LLVector3 pos_agent;

+    pos_agent.setVec(pos_global - mAgentOriginGlobal);

+    return pos_agent;

+}

+

+

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

+// getPosGlobalFromAgent()

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

+LLVector3d LLAgent::getPosGlobalFromAgent(const LLVector3 &pos_agent) const

+{

+    LLVector3d pos_agent_d;

+    pos_agent_d.setVec(pos_agent);

+    return pos_agent_d + mAgentOriginGlobal;

+}

+

+void LLAgent::sitDown()

+{

+    setControlFlags(AGENT_CONTROL_SIT_ON_GROUND);

+}

+

+

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

+// resetAxes()

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

+void LLAgent::resetAxes()

+{

+    mFrameAgent.resetAxes();

+}

+

+

+// Copied from LLCamera::setOriginAndLookAt

+// Look_at must be unit vector

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

+// resetAxes()

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

+void LLAgent::resetAxes(const LLVector3 &look_at)

+{

+    LLVector3   skyward = getReferenceUpVector();

+

+    // if look_at has zero length, fail

+    // if look_at and skyward are parallel, fail

+    //

+    // Test both of these conditions with a cross product.

+    LLVector3 cross(look_at % skyward);

+    if (cross.isNull())

+    {

+        LL_INFOS() << "LLAgent::resetAxes cross-product is zero" << LL_ENDL;

+        return;

+    }

+

+    // Make sure look_at and skyward are not parallel

+    // and neither are zero length

+    LLVector3 left(skyward % look_at);

+    LLVector3 up(look_at % left);

+

+    mFrameAgent.setAxes(look_at, left, up);

+}

+

+

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

+// rotate()

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

+void LLAgent::rotate(F32 angle, const LLVector3 &axis)

+{

+    mFrameAgent.rotate(angle, axis);

+}

+

+

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

+// rotate()

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

+void LLAgent::rotate(F32 angle, F32 x, F32 y, F32 z)

+{

+    mFrameAgent.rotate(angle, x, y, z);

+}

+

+

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

+// rotate()

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

+void LLAgent::rotate(const LLMatrix3 &matrix)

+{

+    mFrameAgent.rotate(matrix);

+}

+

+

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

+// rotate()

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

+void LLAgent::rotate(const LLQuaternion &quaternion)

+{

+    mFrameAgent.rotate(quaternion);

+}

+

+

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

+// getReferenceUpVector()

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

+LLVector3 LLAgent::getReferenceUpVector()

+{

+    // this vector is in the coordinate frame of the avatar's parent object, or the world if none

+    LLVector3 up_vector = LLVector3::z_axis;

+    if (isAgentAvatarValid() &&

+        gAgentAvatarp->getParent() &&

+        gAgentAvatarp->mDrawable.notNull())

+    {

+        U32 camera_mode = gAgentCamera.getCameraAnimating() ? gAgentCamera.getLastCameraMode() : gAgentCamera.getCameraMode();

+        // and in third person...

+        if (camera_mode == CAMERA_MODE_THIRD_PERSON)

+        {

+            // make the up vector point to the absolute +z axis

+            up_vector = up_vector * ~((LLViewerObject*)gAgentAvatarp->getParent())->getRenderRotation();

+        }

+        else if (camera_mode == CAMERA_MODE_MOUSELOOK)

+        {

+            // make the up vector point to the avatar's +z axis

+            up_vector = up_vector * gAgentAvatarp->mDrawable->getRotation();

+        }

+    }

+

+    return up_vector;

+}

+

+

+// Radians, positive is forward into ground

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

+// pitch()

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

+void LLAgent::pitch(F32 angle)

+{

+    // don't let user pitch if pointed almost all the way down or up

+

+    // A dot B = mag(A) * mag(B) * cos(angle between A and B)

+    // so... cos(angle between A and B) = A dot B / mag(A) / mag(B)

+    //                                  = A dot B for unit vectors

+

+    LLVector3 skyward = getReferenceUpVector();

+

+    // clamp pitch to limits

+    if (angle >= 0.f)

+    {

+        const F32 look_down_limit = 179.f * DEG_TO_RAD;

+        F32 angle_from_skyward = acos(mFrameAgent.getAtAxis() * skyward);

+        if (angle_from_skyward + angle > look_down_limit)

+        {

+            angle = look_down_limit - angle_from_skyward;

+        }

+    }

+    else if (angle < 0.f)

+    {

+        const F32 look_up_limit = 5.f * DEG_TO_RAD;

+        const LLVector3& viewer_camera_pos = LLViewerCamera::getInstance()->getOrigin();

+        LLVector3 agent_focus_pos = getPosAgentFromGlobal(gAgentCamera.calcFocusPositionTargetGlobal());

+        LLVector3 look_dir = agent_focus_pos - viewer_camera_pos;

+        F32 angle_from_skyward = angle_between(look_dir, skyward);

+        if (angle_from_skyward + angle < look_up_limit)

+        {

+            angle = look_up_limit - angle_from_skyward;

+        }

+    }

+

+    if (fabs(angle) > 1e-4)

+    {

+        mFrameAgent.pitch(angle);

+    }

+}

+

+

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

+// roll()

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

+void LLAgent::roll(F32 angle)

+{

+    mFrameAgent.roll(angle);

+}

+

+

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

+// yaw()

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

+void LLAgent::yaw(F32 angle)

+{

+    if (!rotateGrabbed())

+    {

+        mFrameAgent.rotate(angle, getReferenceUpVector());

+    }

+}

+

+

+// Returns a quat that represents the rotation of the agent in the absolute frame

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

+// getQuat()

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

+LLQuaternion LLAgent::getQuat() const

+{

+    return mFrameAgent.getQuaternion();

+}

+

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

+// getControlFlags()

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

+U32 LLAgent::getControlFlags()

+{

+    return mControlFlags;

+}

+

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

+// setControlFlags()

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

+void LLAgent::setControlFlags(U32 mask)

+{

+    mControlFlags |= mask;

+    mbFlagsDirty = true;

+}

+

+

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

+// clearControlFlags()

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

+void LLAgent::clearControlFlags(U32 mask)

+{

+    U32 old_flags = mControlFlags;

+    mControlFlags &= ~mask;

+    if (old_flags != mControlFlags)

+    {

+        mbFlagsDirty = true;

+    }

+}

+

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

+// controlFlagsDirty()

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

+bool LLAgent::controlFlagsDirty() const

+{

+    return mbFlagsDirty;

+}

+

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

+// enableControlFlagReset()

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

+void LLAgent::enableControlFlagReset()

+{

+    mbFlagsNeedReset = true;

+}

+

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

+// resetControlFlags()

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

+void LLAgent::resetControlFlags()

+{

+    if (mbFlagsNeedReset)

+    {

+        mbFlagsNeedReset = false;

+        mbFlagsDirty = false;

+        // reset all of the ephemeral flags

+        // some flags are managed elsewhere

+        mControlFlags &= AGENT_CONTROL_AWAY | AGENT_CONTROL_FLY | AGENT_CONTROL_MOUSELOOK;

+    }

+}

+

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

+// setAFK()

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

+void LLAgent::setAFK()

+{

+    if (gNonInteractive || !gAgent.getRegion())

+    {

+        // Don't set AFK if we're not talking to a region yet.

+        return;

+    }

+

+    if (!(mControlFlags & AGENT_CONTROL_AWAY))

+    {

+        sendAnimationRequest(ANIM_AGENT_AWAY, ANIM_REQUEST_START);

+        setControlFlags(AGENT_CONTROL_AWAY | AGENT_CONTROL_STOP);

+        gAwayTimer.start();

+    }

+}

+

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

+// clearAFK()

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

+void LLAgent::clearAFK()

+{

+    gAwayTriggerTimer.reset();

+

+    // Gods can sometimes get into away state (via gestures)

+    // without setting the appropriate control flag. JC

+    if (mControlFlags & AGENT_CONTROL_AWAY

+        || (isAgentAvatarValid()

+            && (gAgentAvatarp->mSignaledAnimations.find(ANIM_AGENT_AWAY) != gAgentAvatarp->mSignaledAnimations.end())))

+    {

+        sendAnimationRequest(ANIM_AGENT_AWAY, ANIM_REQUEST_STOP);

+        clearControlFlags(AGENT_CONTROL_AWAY);

+    }

+}

+

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

+// getAFK()

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

+bool LLAgent::getAFK() const

+{

+    return (mControlFlags & AGENT_CONTROL_AWAY) != 0;

+}

+

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

+// setDoNotDisturb()

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

+void LLAgent::setDoNotDisturb(bool pIsDoNotDisturb)

+{

+    bool isDoNotDisturbSwitchedOff = (mIsDoNotDisturb && !pIsDoNotDisturb);

+    mIsDoNotDisturb = pIsDoNotDisturb;

+    sendAnimationRequest(ANIM_AGENT_DO_NOT_DISTURB, (pIsDoNotDisturb ? ANIM_REQUEST_START : ANIM_REQUEST_STOP));

+    LLNotificationsUI::LLChannelManager::getInstance()->muteAllChannels(pIsDoNotDisturb);

+    if (isDoNotDisturbSwitchedOff)

+    {

+        LLDoNotDisturbNotificationStorage::getInstance()->updateNotifications();

+    }

+    gIMMgr->updateDNDMessageStatus();

+}

+

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

+// isDoNotDisturb()

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

+bool LLAgent::isDoNotDisturb() const

+{

+    return mIsDoNotDisturb;

+}

+

+

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

+// startAutoPilotGlobal()

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

+void LLAgent::startAutoPilotGlobal(

+    const LLVector3d &target_global,

+    const std::string& behavior_name,

+    const LLQuaternion *target_rotation,

+    void (*finish_callback)(bool, void *),

+    void *callback_data,

+    F32 stop_distance,

+    F32 rot_threshold,

+    bool allow_flying)

+{

+    if (!isAgentAvatarValid())

+    {

+        return;

+    }

+

+    if (target_global.isExactlyZero())

+    {

+        LL_WARNS() << "Canceling attempt to start autopilot towards invalid position" << LL_ENDL;

+        return;

+    }

+

+    // Are there any pending callbacks from previous auto pilot requests?

+    if (mAutoPilotFinishedCallback)

+    {

+        mAutoPilotFinishedCallback(dist_vec(gAgent.getPositionGlobal(), mAutoPilotTargetGlobal) < mAutoPilotStopDistance, mAutoPilotCallbackData);

+    }

+

+    mAutoPilotFinishedCallback = finish_callback;

+    mAutoPilotCallbackData = callback_data;

+    mAutoPilotRotationThreshold = rot_threshold;

+    mAutoPilotBehaviorName = behavior_name;

+    mAutoPilotAllowFlying = allow_flying;

+

+    LLVector3d delta_pos( target_global );

+    delta_pos -= getPositionGlobal();

+    F64 distance = delta_pos.magVec();

+    LLVector3d trace_target = target_global;

+

+    trace_target.mdV[VZ] -= 10.f;

+

+    LLVector3d intersection;

+    LLVector3 normal;

+    LLViewerObject *hit_obj;

+    F32 heightDelta = LLWorld::getInstance()->resolveStepHeightGlobal(NULL, target_global, trace_target, intersection, normal, &hit_obj);

+

+    if (stop_distance > 0.f)

+    {

+        mAutoPilotStopDistance = stop_distance;

+    }

+    else

+    {

+        // Guess at a reasonable stop distance.

+        mAutoPilotStopDistance = (F32) sqrt( distance );

+        if (mAutoPilotStopDistance < 0.5f)

+        {

+            mAutoPilotStopDistance = 0.5f;

+        }

+    }

+

+    if (mAutoPilotAllowFlying)

+    {

+        mAutoPilotFlyOnStop = getFlying();

+    }

+    else

+    {

+        mAutoPilotFlyOnStop = false;

+    }

+

+    if (distance > 30.0 && mAutoPilotAllowFlying)

+    {

+        setFlying(true);

+    }

+

+    if ( distance > 1.f &&

+        mAutoPilotAllowFlying &&

+        heightDelta > (sqrtf(mAutoPilotStopDistance) + 1.f))

+    {

+        setFlying(true);

+        // Do not force flying for "Sit" behavior to prevent flying after pressing "Stand"

+        // from an object. See EXT-1655.

+        if ("Sit" != mAutoPilotBehaviorName)

+            mAutoPilotFlyOnStop = true;

+    }

+

+    mAutoPilot = true;

+    setAutoPilotTargetGlobal(target_global);

+

+    if (target_rotation)

+    {

+        mAutoPilotUseRotation = true;

+        mAutoPilotTargetFacing = LLVector3::x_axis * *target_rotation;

+        mAutoPilotTargetFacing.mV[VZ] = 0.f;

+        mAutoPilotTargetFacing.normalize();

+    }

+    else

+    {

+        mAutoPilotUseRotation = false;

+    }

+

+    mAutoPilotNoProgressFrameCount = 0;

+}

+

+

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

+// setAutoPilotTargetGlobal

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

+void LLAgent::setAutoPilotTargetGlobal(const LLVector3d &target_global)

+{

+    if (mAutoPilot)

+    {

+        mAutoPilotTargetGlobal = target_global;

+

+        // trace ray down to find height of destination from ground

+        LLVector3d traceEndPt = target_global;

+        traceEndPt.mdV[VZ] -= 20.f;

+

+        LLVector3d targetOnGround;

+        LLVector3 groundNorm;

+        LLViewerObject *obj;

+

+        LLWorld::getInstance()->resolveStepHeightGlobal(NULL, target_global, traceEndPt, targetOnGround, groundNorm, &obj);

+        // Note: this might malfunction for sitting agent, since pelvis stays same, but agent's position becomes lower

+        // But for autopilot to work we assume that agent is standing and ready to go.

+        F64 target_height = llmax((F64)gAgentAvatarp->getPelvisToFoot(), target_global.mdV[VZ] - targetOnGround.mdV[VZ]);

+

+        // clamp z value of target to minimum height above ground

+        mAutoPilotTargetGlobal.mdV[VZ] = targetOnGround.mdV[VZ] + target_height;

+        mAutoPilotTargetDist = (F32)dist_vec(gAgent.getPositionGlobal(), mAutoPilotTargetGlobal);

+    }

+}

+

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

+// startFollowPilot()

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

+void LLAgent::startFollowPilot(const LLUUID &leader_id, bool allow_flying, F32 stop_distance)

+{

+    mLeaderID = leader_id;

+    if ( mLeaderID.isNull() ) return;

+

+    LLViewerObject* object = gObjectList.findObject(mLeaderID);

+    if (!object)

+    {

+        mLeaderID = LLUUID::null;

+        return;

+    }

+

+    startAutoPilotGlobal(object->getPositionGlobal(),

+                         std::string(), // behavior_name

+                         NULL,          // target_rotation

+                         NULL,          // finish_callback

+                         NULL,          // callback_data

+                         stop_distance,

+                         0.03f,         // rotation_threshold

+                         allow_flying);

+}

+

+

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

+// stopAutoPilot()

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

+void LLAgent::stopAutoPilot(bool user_cancel)

+{

+    if (mAutoPilot)

+    {

+        mAutoPilot = false;

+        if (mAutoPilotUseRotation && !user_cancel)

+        {

+            resetAxes(mAutoPilotTargetFacing);

+        }

+        // Restore previous flying state before invoking mAutoPilotFinishedCallback to allow

+        // callback function to change the flying state (like in near_sit_down_point()).

+        // If the user cancelled, don't change the fly state

+        if (!user_cancel)

+        {

+            setFlying(mAutoPilotFlyOnStop);

+        }

+        //NB: auto pilot can terminate for a reason other than reaching the destination

+        if (mAutoPilotFinishedCallback)

+        {

+            mAutoPilotFinishedCallback(!user_cancel && dist_vec(gAgent.getPositionGlobal(), mAutoPilotTargetGlobal) < mAutoPilotStopDistance, mAutoPilotCallbackData);

+            mAutoPilotFinishedCallback = NULL;

+        }

+        mLeaderID = LLUUID::null;

+

+        setControlFlags(AGENT_CONTROL_STOP);

+

+        if (user_cancel && !mAutoPilotBehaviorName.empty())

+        {

+            if (mAutoPilotBehaviorName == "Sit")

+                LL_INFOS("Agent") << "Autopilot-Sit was canceled by user action" << LL_ENDL;

+            else if (mAutoPilotBehaviorName == "Attach")

+                LLNotificationsUtil::add("CancelledAttach");

+            else

+                LLNotificationsUtil::add("Cancelled");

+        }

+    }

+}

+

+

+// Returns necessary agent pitch and yaw changes, radians.

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

+// autoPilot()

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

+void LLAgent::autoPilot(F32 *delta_yaw)

+{

+    if (mAutoPilot)

+    {

+        if (!mLeaderID.isNull())

+        {

+            LLViewerObject* object = gObjectList.findObject(mLeaderID);

+            if (!object)

+            {

+                stopAutoPilot();

+                return;

+            }

+            mAutoPilotTargetGlobal = object->getPositionGlobal();

+        }

+

+        if (!isAgentAvatarValid()) return;

+

+        if (gAgentAvatarp->mInAir && mAutoPilotAllowFlying)

+        {

+            setFlying(true);

+        }

+

+        LLVector3 at;

+        at.setVec(mFrameAgent.getAtAxis());

+        LLVector3 target_agent = getPosAgentFromGlobal(mAutoPilotTargetGlobal);

+        LLVector3 direction = target_agent - getPositionAgent();

+

+        F32 target_dist = direction.magVec();

+

+        if (target_dist >= mAutoPilotTargetDist)

+        {

+            mAutoPilotNoProgressFrameCount++;

+            bool out_of_time = false;

+            if (getFlying())

+            {

+                out_of_time = mAutoPilotNoProgressFrameCount > AUTOPILOT_MAX_TIME_NO_PROGRESS_FLY * gFPSClamped;

+            }

+            else

+            {

+                out_of_time = mAutoPilotNoProgressFrameCount > AUTOPILOT_MAX_TIME_NO_PROGRESS_WALK * gFPSClamped;

+            }

+            if (out_of_time)

+            {

+                stopAutoPilot();

+                return;

+            }

+        }

+

+        mAutoPilotTargetDist = target_dist;

+

+        // Make this a two-dimensional solution

+        at.mV[VZ] = 0.f;

+        direction.mV[VZ] = 0.f;

+

+        at.normalize();

+        F32 xy_distance = direction.normalize();

+

+        F32 yaw = 0.f;

+        if (mAutoPilotTargetDist > mAutoPilotStopDistance)

+        {

+            yaw = angle_between(mFrameAgent.getAtAxis(), direction);

+        }

+        else if (mAutoPilotUseRotation)

+        {

+            // we're close now just aim at target facing

+            yaw = angle_between(at, mAutoPilotTargetFacing);

+            direction = mAutoPilotTargetFacing;

+        }

+

+        yaw = 4.f * yaw / gFPSClamped;

+

+        // figure out which direction to turn

+        LLVector3 scratch(at % direction);

+

+        if (scratch.mV[VZ] > 0.f)

+        {

+            setControlFlags(AGENT_CONTROL_YAW_POS);

+        }

+        else

+        {

+            yaw = -yaw;

+            setControlFlags(AGENT_CONTROL_YAW_NEG);

+        }

+

+        *delta_yaw = yaw;

+

+        // Compute when to start slowing down

+        F32 slow_distance;

+        if (getFlying())

+        {

+            slow_distance = llmax(8.f, mAutoPilotStopDistance + 5.f);

+        }

+        else

+        {

+            slow_distance = llmax(3.f, mAutoPilotStopDistance + 2.f);

+        }

+

+        // If we're flying, handle autopilot points above or below you.

+        if (getFlying() && xy_distance < AUTOPILOT_HEIGHT_ADJUST_DISTANCE)

+        {

+            if (isAgentAvatarValid())

+            {

+                F64 current_height = gAgentAvatarp->getPositionGlobal().mdV[VZ];

+                F32 delta_z = (F32)(mAutoPilotTargetGlobal.mdV[VZ] - current_height);

+                F32 slope = delta_z / xy_distance;

+                if (slope > 0.45f && delta_z > 6.f)

+                {

+                    setControlFlags(AGENT_CONTROL_FAST_UP | AGENT_CONTROL_UP_POS);

+                }

+                else if (slope > 0.002f && delta_z > 0.5f)

+                {

+                    setControlFlags(AGENT_CONTROL_UP_POS);

+                }

+                else if (slope < -0.45f && delta_z < -6.f && current_height > AUTOPILOT_MIN_TARGET_HEIGHT_OFF_GROUND)

+                {

+                    setControlFlags(AGENT_CONTROL_FAST_UP | AGENT_CONTROL_UP_NEG);

+                }

+                else if (slope < -0.002f && delta_z < -0.5f && current_height > AUTOPILOT_MIN_TARGET_HEIGHT_OFF_GROUND)

+                {

+                    setControlFlags(AGENT_CONTROL_UP_NEG);

+                }

+            }

+        }

+

+        //  calculate delta rotation to target heading

+        F32 delta_target_heading = angle_between(mFrameAgent.getAtAxis(), mAutoPilotTargetFacing);

+

+        if (xy_distance > slow_distance && yaw < (F_PI / 10.f))

+        {

+            // walking/flying fast

+            setControlFlags(AGENT_CONTROL_FAST_AT | AGENT_CONTROL_AT_POS);

+        }

+        else if (mAutoPilotTargetDist > mAutoPilotStopDistance)

+        {

+            // walking/flying slow

+            U32 movement_flag = 0;

+

+            if (at * direction > 0.9f)

+            {

+                movement_flag = AGENT_CONTROL_AT_POS;

+            }

+            else if (at * direction < -0.9f)

+            {

+                movement_flag = AGENT_CONTROL_AT_NEG;

+            }

+

+            if (getFlying())

+            {

+                // flying is too fast and has high inertia, artificially slow it down

+                // Don't update flags too often, server might not react

+                static U64 last_time_microsec = 0;

+                U64 time_microsec = LLTimer::getTotalTime();

+                U64 delta = time_microsec - last_time_microsec;

+                // fly during ~0-40 ms, stop during ~40-250 ms

+                if (delta > 250000) // 250ms

+                {

+                    // reset even if !movement_flag

+                    last_time_microsec = time_microsec;

+                }

+                else if (delta > 40000) // 40 ms

+                {

+                    clearControlFlags(AGENT_CONTROL_AT_POS | AGENT_CONTROL_AT_POS);

+                    movement_flag = 0;

+                }

+            }

+

+            if (movement_flag)

+            {

+                setControlFlags(movement_flag);

+            }

+        }

+

+        // check to see if we need to keep rotating to target orientation

+        if (mAutoPilotTargetDist < mAutoPilotStopDistance)

+        {

+            setControlFlags(AGENT_CONTROL_STOP);

+            if(!mAutoPilotUseRotation || (delta_target_heading < mAutoPilotRotationThreshold))

+            {

+                stopAutoPilot();

+            }

+        }

+    }

+}

+

+

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

+// propagate()

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

+void LLAgent::propagate(const F32 dt)

+{

+    // Update UI based on agent motion

+    LLFloaterMove *floater_move = LLFloaterReg::findTypedInstance<LLFloaterMove>("moveview");

+    if (floater_move)

+    {

+        floater_move->mForwardButton   ->setToggleState( gAgentCamera.getAtKey() > 0 || gAgentCamera.getWalkKey() > 0 );

+        floater_move->mBackwardButton  ->setToggleState( gAgentCamera.getAtKey() < 0 || gAgentCamera.getWalkKey() < 0 );

+        floater_move->mTurnLeftButton  ->setToggleState( gAgentCamera.getYawKey() > 0.f );

+        floater_move->mTurnRightButton ->setToggleState( gAgentCamera.getYawKey() < 0.f );

+        floater_move->mSlideLeftButton  ->setToggleState( gAgentCamera.getLeftKey() > 0.f );

+        floater_move->mSlideRightButton ->setToggleState( gAgentCamera.getLeftKey() < 0.f );

+        floater_move->mMoveUpButton    ->setToggleState( gAgentCamera.getUpKey() > 0 );

+        floater_move->mMoveDownButton  ->setToggleState( gAgentCamera.getUpKey() < 0 );

+    }

+

+    // handle rotation based on keyboard levels

+    const F32 YAW_RATE = 90.f * DEG_TO_RAD;             // radians per second

+    yaw(YAW_RATE * gAgentCamera.getYawKey() * dt);

+

+    const F32 PITCH_RATE = 90.f * DEG_TO_RAD;           // radians per second

+    pitch(PITCH_RATE * gAgentCamera.getPitchKey() * dt);

+

+    // handle auto-land behavior

+    if (isAgentAvatarValid())

+    {

+        bool in_air = gAgentAvatarp->mInAir;

+        LLVector3 land_vel = getVelocity();

+        land_vel.mV[VZ] = 0.f;

+

+        if (!in_air

+            && gAgentCamera.getUpKey() < 0

+            && land_vel.magVecSquared() < MAX_VELOCITY_AUTO_LAND_SQUARED

+            && gSavedSettings.getBOOL("AutomaticFly"))

+        {

+            // land automatically

+            setFlying(false);

+        }

+    }

+

+    gAgentCamera.clearGeneralKeys();

+}

+

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

+// updateAgentPosition()

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

+void LLAgent::updateAgentPosition(const F32 dt, const F32 yaw_radians, const S32 mouse_x, const S32 mouse_y)

+{

+    static LLCachedControl<F32> hint_timeout(gSavedSettings, "NotMovingHintTimeout");

+    if (mMoveTimer.getStarted() && mMoveTimer.getElapsedTimeF32() > hint_timeout)

+    {

+        LLFirstUse::notMoving();

+    }

+

+    propagate(dt);

+

+    // static S32 cameraUpdateCount = 0;

+

+    rotate(yaw_radians, 0, 0, 1);

+

+    //

+    // Check for water and land collision, set underwater flag

+    //

+

+    gAgentCamera.updateLookAt(mouse_x, mouse_y);

+

+    // When agent has no parents, position updates come from setPositionAgent()

+    // But when agent has a parent (ex: is seated), position remains unchanged

+    // relative to parent and no parent's position update trigger

+    // setPositionAgent().

+    // But EEP's sky track selection still needs an update if agent has a parent

+    // and parent moves (ex: vehicles).

+    if (isAgentAvatarValid()

+        && gAgentAvatarp->getParent()

+        && !mOnPositionChanged.empty()

+        )

+    {

+        LLVector3d new_position = getPositionGlobal();

+        if ((mLastTestGlobal - new_position).lengthSquared() > 1.0)

+        {

+            // If the position has changed by more than 1 meter since the last time we triggered.

+            // filters out some noise.

+            mLastTestGlobal = new_position;

+            mOnPositionChanged(mFrameAgent.getOrigin(), new_position);

+        }

+    }

+}

+

+// friends and operators

+

+std::ostream& operator<<(std::ostream &s, const LLAgent &agent)

+{

+    // This is unfinished, but might never be used.

+    // We'll just leave it for now; we can always delete it.

+    s << " { "

+      << "  Frame = " << agent.mFrameAgent << "\n"

+      << " }";

+    return s;

+}

+

+// true if your own avatar needs to be rendered.  Usually only

+// in third person and build.

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

+// needsRenderAvatar()

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

+bool LLAgent::needsRenderAvatar()

+{

+    if (gAgentCamera.cameraMouselook() && !LLVOAvatar::sVisibleInFirstPerson)

+    {

+        return false;

+    }

+

+    return mShowAvatar && mOutfitChosen;

+}

+

+// true if we need to render your own avatar's head.

+bool LLAgent::needsRenderHead()

+{

+    return (LLVOAvatar::sVisibleInFirstPerson && LLPipeline::sReflectionRender) || (mShowAvatar && !gAgentCamera.cameraMouselook());

+}

+

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

+// startTyping()

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

+void LLAgent::startTyping()

+{

+    mTypingTimer.reset();

+

+    if (getRenderState() & AGENT_STATE_TYPING)

+    {

+        // already typing, don't trigger a different animation

+        return;

+    }

+    setRenderState(AGENT_STATE_TYPING);

+

+    if (mChatTimer.getElapsedTimeF32() < 2.f)

+    {

+        LLViewerObject* chatter = gObjectList.findObject(mLastChatterID);

+        if (chatter && chatter->isAvatar())

+        {

+            gAgentCamera.setLookAt(LOOKAT_TARGET_RESPOND, chatter, LLVector3::zero);

+        }

+    }

+

+    if (gSavedSettings.getBOOL("PlayTypingAnim"))

+    {

+        sendAnimationRequest(ANIM_AGENT_TYPE, ANIM_REQUEST_START);

+    }

+    (LLFloaterReg::getTypedInstance<LLFloaterIMNearbyChat>("nearby_chat"))->

+            sendChatFromViewer("", CHAT_TYPE_START, false);

+}

+

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

+// stopTyping()

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

+void LLAgent::stopTyping()

+{

+    if (mRenderState & AGENT_STATE_TYPING)

+    {

+        clearRenderState(AGENT_STATE_TYPING);

+        sendAnimationRequest(ANIM_AGENT_TYPE, ANIM_REQUEST_STOP);

+        (LLFloaterReg::getTypedInstance<LLFloaterIMNearbyChat>("nearby_chat"))->

+                sendChatFromViewer("", CHAT_TYPE_STOP, false);

+    }

+}

+

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

+// setRenderState()

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

+void LLAgent::setRenderState(U8 newstate)

+{

+    mRenderState |= newstate;

+}

+

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

+// clearRenderState()

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

+void LLAgent::clearRenderState(U8 clearstate)

+{

+    mRenderState &= ~clearstate;

+}

+

+

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

+// getRenderState()

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

+U8 LLAgent::getRenderState()

+{

+    // *FIX: don't do stuff in a getter!  This is infinite loop city!

+    if ((mTypingTimer.getElapsedTimeF32() > TYPING_TIMEOUT_SECS)

+        && (mRenderState & AGENT_STATE_TYPING))

+    {

+        stopTyping();

+    }

+

+    if ((!LLSelectMgr::getInstance()->getSelection()->isEmpty() && LLSelectMgr::getInstance()->shouldShowSelection())

+        || LLToolMgr::getInstance()->getCurrentTool()->isEditing() )

+    {

+        setRenderState(AGENT_STATE_EDITING);

+    }

+    else

+    {

+        clearRenderState(AGENT_STATE_EDITING);

+    }

+

+    return mRenderState;

+}

+

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

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

+

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

+// endAnimationUpdateUI()

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

+void LLAgent::endAnimationUpdateUI()

+{

+    if (LLApp::isExiting()

+        || !gViewerWindow

+        || !gMenuBarView

+        || !gToolBarView

+        || !gStatusBar)

+    {

+        return;

+    }

+    if (gAgentCamera.getCameraMode() == gAgentCamera.getLastCameraMode())

+    {

+        // We're already done endAnimationUpdateUI for this transition.

+        return;

+    }

+

+    // clean up UI from mode we're leaving

+    if (gAgentCamera.getLastCameraMode() == CAMERA_MODE_MOUSELOOK )

+    {

+        gToolBarView->setToolBarsVisible(true);

+        // show mouse cursor

+        gViewerWindow->showCursor();

+        // show menus

+        gMenuBarView->setVisible(true);

+        LLNavigationBar::getInstance()->setVisible(true && gSavedSettings.getBOOL("ShowNavbarNavigationPanel"));

+        gStatusBar->setVisibleForMouselook(true);

+

+        static LLCachedControl<bool> show_mini_location_panel(gSavedSettings, "ShowMiniLocationPanel");

+        if (show_mini_location_panel)

+        {

+            LLPanelTopInfoBar::getInstance()->setVisible(true);

+        }

+

+        LLChicletBar::getInstance()->setVisible(true);

+

+        LLPanelStandStopFlying::getInstance()->setVisible(true);

+

+        LLToolMgr::getInstance()->setCurrentToolset(gBasicToolset);

+

+        LLFloaterCamera::onLeavingMouseLook();

+

+        if (mMouselookModeOutSignal)

+        {

+            (*mMouselookModeOutSignal)();

+        }

+

+        // Only pop if we have pushed...

+        if (true == mViewsPushed)

+        {

+#if 0 // Use this once all floaters are registered

+            LLFloaterReg::restoreVisibleInstances();

+#else // Use this for now

+            LLFloaterView::skip_list_t skip_list;

+            if (LLFloaterReg::findInstance("mini_map"))

+            {

+                skip_list.insert(LLFloaterReg::findInstance("mini_map"));

+            }

+            if (LLFloaterReg::findInstance("beacons"))

+            {

+                skip_list.insert(LLFloaterReg::findInstance("beacons"));

+            }

+            LLFloaterIMContainer* im_box = LLFloaterReg::getTypedInstance<LLFloaterIMContainer>("im_container");

+            LLFloaterIMContainer::floater_list_t conversations;

+            im_box->getDetachedConversationFloaters(conversations);

+            for (LLFloater* conversation : conversations)

+            {

+                LL_INFOS() << "skip_list.insert(session_floater): " << conversation->getTitle() << LL_ENDL;

+                skip_list.insert(conversation);

+            }

+

+            gFloaterView->popVisibleAll(skip_list);

+#endif

+            mViewsPushed = false;

+        }

+

+

+        gAgentCamera.setLookAt(LOOKAT_TARGET_CLEAR);

+        if( gMorphView )

+        {

+            gMorphView->setVisible( false );

+        }

+

+        // Disable mouselook-specific animations

+        if (isAgentAvatarValid())

+        {

+            if( gAgentAvatarp->isAnyAnimationSignaled(AGENT_GUN_AIM_ANIMS, NUM_AGENT_GUN_AIM_ANIMS) )

+            {

+                if (gAgentAvatarp->mSignaledAnimations.find(ANIM_AGENT_AIM_RIFLE_R) != gAgentAvatarp->mSignaledAnimations.end())

+                {

+                    sendAnimationRequest(ANIM_AGENT_AIM_RIFLE_R, ANIM_REQUEST_STOP);

+                    sendAnimationRequest(ANIM_AGENT_HOLD_RIFLE_R, ANIM_REQUEST_START);

+                }

+                if (gAgentAvatarp->mSignaledAnimations.find(ANIM_AGENT_AIM_HANDGUN_R) != gAgentAvatarp->mSignaledAnimations.end())

+                {

+                    sendAnimationRequest(ANIM_AGENT_AIM_HANDGUN_R, ANIM_REQUEST_STOP);

+                    sendAnimationRequest(ANIM_AGENT_HOLD_HANDGUN_R, ANIM_REQUEST_START);

+                }

+                if (gAgentAvatarp->mSignaledAnimations.find(ANIM_AGENT_AIM_BAZOOKA_R) != gAgentAvatarp->mSignaledAnimations.end())

+                {

+                    sendAnimationRequest(ANIM_AGENT_AIM_BAZOOKA_R, ANIM_REQUEST_STOP);

+                    sendAnimationRequest(ANIM_AGENT_HOLD_BAZOOKA_R, ANIM_REQUEST_START);

+                }

+                if (gAgentAvatarp->mSignaledAnimations.find(ANIM_AGENT_AIM_BOW_L) != gAgentAvatarp->mSignaledAnimations.end())

+                {

+                    sendAnimationRequest(ANIM_AGENT_AIM_BOW_L, ANIM_REQUEST_STOP);

+                    sendAnimationRequest(ANIM_AGENT_HOLD_BOW_L, ANIM_REQUEST_START);

+                }

+            }

+        }

+    }

+    else if (gAgentCamera.getLastCameraMode() == CAMERA_MODE_CUSTOMIZE_AVATAR)

+    {

+        // make sure we ask to save changes

+

+        LLToolMgr::getInstance()->setCurrentToolset(gBasicToolset);

+

+        if( gMorphView )

+        {

+            gMorphView->setVisible( false );

+        }

+

+        if (isAgentAvatarValid())

+        {

+            if(mCustomAnim)

+            {

+                sendAnimationRequest(ANIM_AGENT_CUSTOMIZE, ANIM_REQUEST_STOP);

+                sendAnimationRequest(ANIM_AGENT_CUSTOMIZE_DONE, ANIM_REQUEST_START);

+

+                mCustomAnim = false ;

+            }

+

+        }

+        gAgentCamera.setLookAt(LOOKAT_TARGET_CLEAR);

+

+        LLFloaterCamera::onAvatarEditingAppearance(false);

+    }

+

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

+    // Set up UI for mode we're entering

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

+    if (gAgentCamera.getCameraMode() == CAMERA_MODE_MOUSELOOK)

+    {

+        // clean up UI

+        // first show anything hidden by UI toggle

+        gViewerWindow->setUIVisibility(true);

+

+        // then hide stuff we want hidden for mouselook

+        gToolBarView->setToolBarsVisible(false);

+        gMenuBarView->setVisible(false);

+        LLNavigationBar::getInstance()->setVisible(false);

+        gStatusBar->setVisibleForMouselook(false);

+

+        LLPanelTopInfoBar::getInstance()->setVisible(false);

+

+        LLChicletBar::getInstance()->setVisible(false);

+

+        LLPanelStandStopFlying::getInstance()->setVisible(false);

+

+        // clear out camera lag effect

+        gAgentCamera.clearCameraLag();

+

+        // JC - Added for always chat in third person option

+        gFocusMgr.setKeyboardFocus(NULL);

+

+        LLToolMgr::getInstance()->setCurrentToolset(gMouselookToolset);

+

+        mViewsPushed = true;

+

+        if (mMouselookModeInSignal)

+        {

+            (*mMouselookModeInSignal)();

+        }

+

+        // hide all floaters except the mini map

+

+#if 0 // Use this once all floaters are registered

+        std::set<std::string> exceptions;

+        exceptions.insert("mini_map");

+        LLFloaterReg::hideVisibleInstances(exceptions);

+#else // Use this for now

+        LLFloaterView::skip_list_t skip_list;

+        skip_list.insert(LLFloaterReg::findInstance("mini_map"));

+        skip_list.insert(LLFloaterReg::findInstance("beacons"));

+        gFloaterView->pushVisibleAll(false, skip_list);

+#endif

+

+        if( gMorphView )

+        {

+            gMorphView->setVisible(false);

+        }

+

+        gConsole->setVisible( true );

+

+        if (isAgentAvatarValid())

+        {

+            // Trigger mouselook-specific animations

+            if( gAgentAvatarp->isAnyAnimationSignaled(AGENT_GUN_HOLD_ANIMS, NUM_AGENT_GUN_HOLD_ANIMS) )

+            {

+                if (gAgentAvatarp->mSignaledAnimations.find(ANIM_AGENT_HOLD_RIFLE_R) != gAgentAvatarp->mSignaledAnimations.end())

+                {

+                    sendAnimationRequest(ANIM_AGENT_HOLD_RIFLE_R, ANIM_REQUEST_STOP);

+                    sendAnimationRequest(ANIM_AGENT_AIM_RIFLE_R, ANIM_REQUEST_START);

+                }

+                if (gAgentAvatarp->mSignaledAnimations.find(ANIM_AGENT_HOLD_HANDGUN_R) != gAgentAvatarp->mSignaledAnimations.end())

+                {

+                    sendAnimationRequest(ANIM_AGENT_HOLD_HANDGUN_R, ANIM_REQUEST_STOP);

+                    sendAnimationRequest(ANIM_AGENT_AIM_HANDGUN_R, ANIM_REQUEST_START);

+                }

+                if (gAgentAvatarp->mSignaledAnimations.find(ANIM_AGENT_HOLD_BAZOOKA_R) != gAgentAvatarp->mSignaledAnimations.end())

+                {

+                    sendAnimationRequest(ANIM_AGENT_HOLD_BAZOOKA_R, ANIM_REQUEST_STOP);

+                    sendAnimationRequest(ANIM_AGENT_AIM_BAZOOKA_R, ANIM_REQUEST_START);

+                }

+                if (gAgentAvatarp->mSignaledAnimations.find(ANIM_AGENT_HOLD_BOW_L) != gAgentAvatarp->mSignaledAnimations.end())

+                {

+                    sendAnimationRequest(ANIM_AGENT_HOLD_BOW_L, ANIM_REQUEST_STOP);

+                    sendAnimationRequest(ANIM_AGENT_AIM_BOW_L, ANIM_REQUEST_START);

+                }

+            }

+            if (gAgentAvatarp->getParent())

+            {

+                LLVector3 at_axis = LLViewerCamera::getInstance()->getAtAxis();

+                LLViewerObject* root_object = (LLViewerObject*)gAgentAvatarp->getRoot();

+                if (root_object->flagCameraDecoupled())

+                {

+                    resetAxes(at_axis);

+                }

+                else

+                {

+                    resetAxes(at_axis * ~((LLViewerObject*)gAgentAvatarp->getParent())->getRenderRotation());

+                }

+            }

+        }

+    }

+    else if (gAgentCamera.getCameraMode() == CAMERA_MODE_CUSTOMIZE_AVATAR)

+    {

+        LLToolMgr::getInstance()->setCurrentToolset(gFaceEditToolset);

+

+        if( gMorphView )

+        {

+            gMorphView->setVisible( true );

+        }

+

+        // freeze avatar

+        if (isAgentAvatarValid())

+        {

+            mPauseRequest = gAgentAvatarp->requestPause();

+        }

+

+        LLFloaterCamera::onAvatarEditingAppearance(true);

+    }

+

+    if (isAgentAvatarValid())

+    {

+        gAgentAvatarp->updateAttachmentVisibility(gAgentCamera.getCameraMode());

+    }

+

+    gFloaterTools->dirty();

+

+    // Don't let this be called more than once if the camera

+    // mode hasn't changed.  --JC

+    gAgentCamera.updateLastCamera();

+}

+

+boost::signals2::connection LLAgent::setMouselookModeInCallback( const camera_signal_t::slot_type& cb )

+{

+    if (!mMouselookModeInSignal) mMouselookModeInSignal = new camera_signal_t();

+    return mMouselookModeInSignal->connect(cb);

+}

+

+boost::signals2::connection LLAgent::setMouselookModeOutCallback( const camera_signal_t::slot_type& cb )

+{

+    if (!mMouselookModeOutSignal) mMouselookModeOutSignal = new camera_signal_t();

+    return mMouselookModeOutSignal->connect(cb);

+}

+

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

+// heardChat()

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

+void LLAgent::heardChat(const LLUUID& id)

+{

+    // log text and voice chat to speaker mgr

+    // for keeping track of active speakers, etc.

+    LLLocalSpeakerMgr::getInstance()->speakerChatted(id);

+

+    // don't respond to your own voice

+    if (id == getID()) return;

+

+    if (ll_rand(2) == 0)

+    {

+        LLViewerObject *chatter = gObjectList.findObject(mLastChatterID);

+        gAgentCamera.setLookAt(LOOKAT_TARGET_AUTO_LISTEN, chatter, LLVector3::zero);

+    }

+

+    mLastChatterID = id;

+    mChatTimer.reset();

+}

+

+LLSD ll_sdmap_from_vector3(const LLVector3& vec)

+{

+    LLSD ret;

+    ret["X"] = vec.mV[VX];

+    ret["Y"] = vec.mV[VY];

+    ret["Z"] = vec.mV[VZ];

+    return ret;

+}

+

+LLVector3 ll_vector3_from_sdmap(const LLSD& sd)

+{

+    LLVector3 ret;

+    ret.mV[VX] = F32(sd["X"].asReal());

+    ret.mV[VY] = F32(sd["Y"].asReal());

+    ret.mV[VZ] = F32(sd["Z"].asReal());

+    return ret;

+}

+

+void LLAgent::setStartPosition( U32 location_id )

+{

+    LLViewerObject          *object;

+

+    if (gAgentID == LLUUID::null)

+    {

+        return;

+    }

+    // we've got an ID for an agent viewerobject

+    object = gObjectList.findObject(gAgentID);

+    if (! object)

+    {

+        LL_INFOS() << "setStartPosition - Can't find agent viewerobject id " << gAgentID << LL_ENDL;

+        return;

+    }

+    // we've got the viewer object

+    // Sometimes the agent can be velocity interpolated off of

+    // this simulator.  Clamp it to the region the agent is

+    // in, a little bit in on each side.

+    const F32 INSET = 0.5f; //meters

+    const F32 REGION_WIDTH = LLWorld::getInstance()->getRegionWidthInMeters();

+

+    LLVector3 agent_pos = getPositionAgent();

+

+    if (isAgentAvatarValid())

+    {

+        // the z height is at the agent's feet

+        agent_pos.mV[VZ] -= 0.5f * (gAgentAvatarp->mBodySize.mV[VZ] + gAgentAvatarp->mAvatarOffset.mV[VZ]);

+    }

+

+    agent_pos.mV[VX] = llclamp( agent_pos.mV[VX], INSET, REGION_WIDTH - INSET );

+    agent_pos.mV[VY] = llclamp( agent_pos.mV[VY], INSET, REGION_WIDTH - INSET );

+

+    // Don't let them go below ground, or too high.

+    agent_pos.mV[VZ] = llclamp( agent_pos.mV[VZ],

+                                mRegionp->getLandHeightRegion( agent_pos ),

+                                LLWorld::getInstance()->getRegionMaxHeight() );

+    // Send the CapReq

+    LLSD request;

+    LLSD body;

+    LLSD homeLocation;

+

+    homeLocation["LocationId"] = LLSD::Integer(location_id);

+    homeLocation["LocationPos"] = ll_sdmap_from_vector3(agent_pos);

+    homeLocation["LocationLookAt"] = ll_sdmap_from_vector3(mFrameAgent.getAtAxis());

+

+    body["HomeLocation"] = homeLocation;

+

+    if (!requestPostCapability("HomeLocation", body,

+            boost::bind(&LLAgent::setStartPositionSuccess, this, _1)))

+        LL_WARNS() << "Unable to post to HomeLocation capability." << LL_ENDL;

+}

+

+void LLAgent::setStartPositionSuccess(const LLSD &result)

+{

+    LLVector3 agent_pos;

+    bool      error = true;

+

+    do {

+        // was the call to /agent/<agent-id>/home-location successful?

+        // If not, we keep error set to true

+        if (!result.has("success"))

+            break;

+

+        if (0 != strncmp("true", result["success"].asString().c_str(), 4))

+            break;

+

+        // did the simulator return a "justified" home location?

+        // If no, we keep error set to true

+        if (!result.has("HomeLocation"))

+            break;

+

+        if ((!result["HomeLocation"].has("LocationPos")) ||

+                (!result["HomeLocation"]["LocationPos"].has("X")) ||

+                (!result["HomeLocation"]["LocationPos"].has("Y")) ||

+                (!result["HomeLocation"]["LocationPos"].has("Z")))

+            break;

+

+        agent_pos.mV[VX] = result["HomeLocation"]["LocationPos"]["X"].asInteger();

+        agent_pos.mV[VY] = result["HomeLocation"]["LocationPos"]["Y"].asInteger();

+        agent_pos.mV[VZ] = result["HomeLocation"]["LocationPos"]["Z"].asInteger();

+

+        error = false;

+

+    } while (0);

+

+    if (error)

+    {

+        LL_WARNS() << "Error in response to home position set." << LL_ENDL;

+    }

+    else

+    {

+        LL_INFOS() << "setting home position" << LL_ENDL;

+

+        LLViewerRegion *viewer_region = gAgent.getRegion();

+        setHomePosRegion(viewer_region->getHandle(), agent_pos);

+    }

+}

+

+void LLAgent::requestStopMotion( LLMotion* motion )

+{

+    // Notify all avatars that a motion has stopped.

+    // This is needed to clear the animation state bits

+    LLUUID anim_state = motion->getID();

+    onAnimStop(motion->getID());

+

+    // if motion is not looping, it could have stopped by running out of time

+    // so we need to tell the server this

+//  LL_INFOS() << "Sending stop for motion " << motion->getName() << LL_ENDL;

+    sendAnimationRequest( anim_state, ANIM_REQUEST_STOP );

+}

+

+void LLAgent::onAnimStop(const LLUUID& id)

+{

+    // handle automatic state transitions (based on completion of animation playback)

+    if (id == ANIM_AGENT_STAND)

+    {

+        stopFidget();

+    }

+    else if (id == ANIM_AGENT_AWAY)

+    {

+        clearAFK();

+    }

+    else if (id == ANIM_AGENT_STANDUP)

+    {

+        // send stand up command

+        setControlFlags(AGENT_CONTROL_FINISH_ANIM);

+

+        // now trigger dusting self off animation

+        if (isAgentAvatarValid() && !gAgentAvatarp->mBelowWater && rand() % 3 == 0)

+            sendAnimationRequest( ANIM_AGENT_BRUSH, ANIM_REQUEST_START );

+    }

+    else if (id == ANIM_AGENT_PRE_JUMP || id == ANIM_AGENT_LAND || id == ANIM_AGENT_MEDIUM_LAND)

+    {

+        setControlFlags(AGENT_CONTROL_FINISH_ANIM);

+    }

+}

+

+bool LLAgent::isGodlike() const

+{

+    return mAgentAccess->isGodlike();

+}

+

+bool LLAgent::isGodlikeWithoutAdminMenuFakery() const

+{

+    return mAgentAccess->isGodlikeWithoutAdminMenuFakery();

+}

+

+U8 LLAgent::getGodLevel() const

+{

+    return mAgentAccess->getGodLevel();

+}

+

+bool LLAgent::wantsPGOnly() const

+{

+    return mAgentAccess->wantsPGOnly();

+}

+

+bool LLAgent::canAccessMature() const

+{

+    return mAgentAccess->canAccessMature();

+}

+

+bool LLAgent::canAccessAdult() const

+{

+    return mAgentAccess->canAccessAdult();

+}

+

+bool LLAgent::canAccessMaturityInRegion( U64 region_handle ) const

+{

+    LLViewerRegion *regionp = LLWorld::getInstance()->getRegionFromHandle( region_handle );

+    if( regionp )

+    {

+        switch( regionp->getSimAccess() )

+        {

+            case SIM_ACCESS_MATURE:

+                if( !canAccessMature() )

+                    return false;

+                break;

+            case SIM_ACCESS_ADULT:

+                if( !canAccessAdult() )

+                    return false;

+                break;

+            default:

+                // Oh, go on and hear the silly noises.

+                break;

+        }

+    }

+

+    return true;

+}

+

+bool LLAgent::canAccessMaturityAtGlobal( LLVector3d pos_global ) const

+{

+    U64 region_handle = to_region_handle_global( pos_global.mdV[0], pos_global.mdV[1] );

+    return canAccessMaturityInRegion( region_handle );

+}

+

+bool LLAgent::prefersPG() const

+{

+    return mAgentAccess->prefersPG();

+}

+

+bool LLAgent::prefersMature() const

+{

+    return mAgentAccess->prefersMature();

+}

+

+bool LLAgent::prefersAdult() const

+{

+    return mAgentAccess->prefersAdult();

+}

+

+bool LLAgent::isTeen() const

+{

+    return mAgentAccess->isTeen();

+}

+

+bool LLAgent::isMature() const

+{

+    return mAgentAccess->isMature();

+}

+

+bool LLAgent::isAdult() const

+{

+    return mAgentAccess->isAdult();

+}

+

+//static

+int LLAgent::convertTextToMaturity(char text)

+{

+    return LLAgentAccess::convertTextToMaturity(text);

+}

+

+void LLAgent::handlePreferredMaturityResult(U8 pServerMaturity)

+{

+    // Update the number of responses received

+    ++mMaturityPreferenceResponseId;

+    llassert(mMaturityPreferenceResponseId <= mMaturityPreferenceRequestId);

+

+    // Update the last known server maturity response

+    mLastKnownResponseMaturity = pServerMaturity;

+

+    // Ignore all responses if we know there are more unanswered requests that are expected

+    if (mMaturityPreferenceResponseId == mMaturityPreferenceRequestId)

+    {

+        // If we received a response that matches the last known request, then we are good

+        if (mLastKnownRequestMaturity == mLastKnownResponseMaturity)

+        {

+            mMaturityPreferenceNumRetries = 0;

+            reportPreferredMaturitySuccess();

+            llassert(static_cast<U8>(gSavedSettings.getU32("PreferredMaturity")) == mLastKnownResponseMaturity);

+        }

+        // Else, the viewer is out of sync with the server, so let's try to re-sync with the

+        // server by re-sending our last known request.  Cap the re-tries at 3 just to be safe.

+        else if (++mMaturityPreferenceNumRetries <= 3)

+        {

+            LL_INFOS() << "Retrying attempt #" << mMaturityPreferenceNumRetries << " to set viewer preferred maturity to '"

+                << LLViewerRegion::accessToString(mLastKnownRequestMaturity) << "'" << LL_ENDL;

+            sendMaturityPreferenceToServer(mLastKnownRequestMaturity);

+        }

+        // Else, the viewer is style out of sync with the server after 3 retries, so inform the user

+        else

+        {

+            mMaturityPreferenceNumRetries = 0;

+            LL_WARNS() << "Too many retries for maturity preference" << LL_ENDL;

+            reportPreferredMaturityError();

+        }

+    }

+}

+

+void LLAgent::handlePreferredMaturityError()

+{

+    // Update the number of responses received

+    ++mMaturityPreferenceResponseId;

+    llassert(mMaturityPreferenceResponseId <= mMaturityPreferenceRequestId);

+

+    // Ignore all responses if we know there are more unanswered requests that are expected

+    if (mMaturityPreferenceResponseId == mMaturityPreferenceRequestId)

+    {

+        mMaturityPreferenceNumRetries = 0;

+

+        // If we received a response that matches the last known request, then we are synced with

+        // the server, but not quite sure why we are

+        if (mLastKnownRequestMaturity == mLastKnownResponseMaturity)

+        {

+            LL_WARNS() << "Got an error but maturity preference '" << LLViewerRegion::accessToString(mLastKnownRequestMaturity)

+                << "' seems to be in sync with the server" << LL_ENDL;

+            reportPreferredMaturitySuccess();

+        }

+        // Else, the more likely case is that the last request does not match the last response,

+        // so inform the user

+        else

+        {

+            reportPreferredMaturityError();

+        }

+    }

+}

+

+void LLAgent::reportPreferredMaturitySuccess()

+{

+    // If there is a pending teleport request waiting for the maturity preference to be synced with

+    // the server, let's start the pending request

+    if (hasPendingTeleportRequest())

+    {

+        startTeleportRequest();

+    }

+}

+

+void LLAgent::reportPreferredMaturityError()

+{

+    // If there is a pending teleport request waiting for the maturity preference to be synced with

+    // the server, we were unable to successfully sync with the server on maturity preference, so let's

+    // just raise the screen.

+    mIsMaturityRatingChangingDuringTeleport = false;

+    if (hasPendingTeleportRequest())

+    {

+        LL_WARNS("Teleport") << "Teleport failing due to preferred maturity error" << LL_ENDL;

+        setTeleportState(LLAgent::TELEPORT_NONE);

+    }

+

+    // Get the last known maturity request from the user activity

+    std::string preferredMaturity = LLViewerRegion::accessToString(mLastKnownRequestMaturity);

+    LLStringUtil::toLower(preferredMaturity);

+

+    // Get the last known maturity response from the server

+    std::string actualMaturity = LLViewerRegion::accessToString(mLastKnownResponseMaturity);

+    LLStringUtil::toLower(actualMaturity);

+

+    // Notify the user

+    LLSD args = LLSD::emptyMap();

+    args["PREFERRED_MATURITY"] = preferredMaturity;

+    args["ACTUAL_MATURITY"] = actualMaturity;

+    LLNotificationsUtil::add("MaturityChangeError", args);

+

+    // Check the saved settings to ensure that we are consistent.  If we are not consistent, update

+    // the viewer, but do not send anything to server

+    U8 localMaturity = static_cast<U8>(gSavedSettings.getU32("PreferredMaturity"));

+    if (localMaturity != mLastKnownResponseMaturity)

+    {

+        bool tmpIsDoSendMaturityPreferenceToServer = mIsDoSendMaturityPreferenceToServer;

+        mIsDoSendMaturityPreferenceToServer = false;

+        LL_INFOS() << "Setting viewer preferred maturity to '" << LLViewerRegion::accessToString(mLastKnownResponseMaturity) << "'" << LL_ENDL;

+        gSavedSettings.setU32("PreferredMaturity", static_cast<U32>(mLastKnownResponseMaturity));

+        mIsDoSendMaturityPreferenceToServer = tmpIsDoSendMaturityPreferenceToServer;

+    }

+}

+

+bool LLAgent::isMaturityPreferenceSyncedWithServer() const

+{

+    return (mMaturityPreferenceRequestId == mMaturityPreferenceResponseId);

+}

+

+void LLAgent::sendMaturityPreferenceToServer(U8 pPreferredMaturity)

+{

+    // Only send maturity preference to the server if enabled

+    if (mIsDoSendMaturityPreferenceToServer)

+    {

+        // Increment the number of requests.  The handlers manage a separate count of responses.

+        ++mMaturityPreferenceRequestId;

+

+        // Update the last know maturity request

+        mLastKnownRequestMaturity = pPreferredMaturity;

+

+        // If we don't have a region, report it as an error

+        if (getRegion() == NULL)

+        {

+            LL_WARNS("Agent") << "Region is not defined, can not change Maturity setting." << LL_ENDL;

+            return;

+        }

+

+        LLSD access_prefs = LLSD::emptyMap();

+        access_prefs["max"] = LLViewerRegion::accessToShortString(pPreferredMaturity);

+

+        LLSD postData = LLSD::emptyMap();

+        postData["access_prefs"] = access_prefs;

+        LL_INFOS() << "Sending viewer preferred maturity to '" << LLViewerRegion::accessToString(pPreferredMaturity) << LL_ENDL;

+

+        if (!requestPostCapability("UpdateAgentInformation", postData,

+            static_cast<httpCallback_t>(boost::bind(&LLAgent::processMaturityPreferenceFromServer, this, _1, pPreferredMaturity)),

+            static_cast<httpCallback_t>(boost::bind(&LLAgent::handlePreferredMaturityError, this))

+            ))

+        {

+            LL_WARNS("Agent") << "Maturity request post failed." << LL_ENDL;

+        }

+    }

+}

+

+

+void LLAgent::processMaturityPreferenceFromServer(const LLSD &result, U8 perferredMaturity)

+{

+    U8 maturity = SIM_ACCESS_MIN;

+

+    llassert(result.isDefined());

+    llassert(result.isMap());

+    llassert(result.has("access_prefs"));

+    llassert(result.get("access_prefs").isMap());

+    llassert(result.get("access_prefs").has("max"));

+    llassert(result.get("access_prefs").get("max").isString());

+    if (result.isDefined() && result.isMap() && result.has("access_prefs")

+        && result.get("access_prefs").isMap() && result.get("access_prefs").has("max")

+        && result.get("access_prefs").get("max").isString())

+    {

+        LLSD::String actualPreference = result.get("access_prefs").get("max").asString();

+        LLStringUtil::trim(actualPreference);

+        maturity = LLViewerRegion::shortStringToAccess(actualPreference);

+    }

+

+    if (maturity != perferredMaturity)

+    {

+        LL_WARNS() << "while attempting to change maturity preference from '"

+            << LLViewerRegion::accessToString(mLastKnownResponseMaturity)

+            << "' to '" << LLViewerRegion::accessToString(perferredMaturity)

+            << "', the server responded with '"

+            << LLViewerRegion::accessToString(maturity)

+            << "' [value:" << static_cast<U32>(maturity)

+            << "], " << LL_ENDL;

+    }

+    handlePreferredMaturityResult(maturity);

+}

+

+// Using a new capability, tell the simulator that we want it to send everything

+// it knows about and not just what is in front of the camera, in its view

+// frustum. We need this feature so that the contents of the region that appears

+// in the 6 snapshots which we cannot see and is normally not "considered", is

+// also rendered. Typically, this is turned on when the 360 capture floater is

+// opened and turned off when it is closed.

+// Note: for this version, we do not have a way to determine when "everything"

+// has arrived and has been rendered so for now, the proposal is that users

+// will need to experiment with the low resolution version and wait for some

+// (hopefully) small period of time while the full contents resolves.

+// Pass in a flag to ask the simulator/interest list to "send everything" or

+// not (the default mode)

+void LLAgent::changeInterestListMode(const std::string &new_mode)

+{

+    if (new_mode != mInterestListMode)

+    {

+        mInterestListMode = new_mode;

+

+        // Change interest list mode for all regions.  If they are already set for the current mode,

+        // the setting will have no effect.

+        for (LLWorld::region_list_t::const_iterator iter = LLWorld::getInstance()->getRegionList().begin();

+             iter != LLWorld::getInstance()->getRegionList().end();

+             ++iter)

+        {

+            LLViewerRegion *regionp = *iter;

+            if (regionp && regionp->isAlive() && regionp->capabilitiesReceived())

+            {

+                regionp->setInterestListMode(mInterestListMode);

+            }

+        }

+    }

+    else

+    {

+        LL_DEBUGS("360Capture") << "Agent interest list mode is already set to " << mInterestListMode << LL_ENDL;

+    }

+}

+

+

+bool LLAgent::requestPostCapability(const std::string &capName, LLSD &postData, httpCallback_t cbSuccess, httpCallback_t cbFailure)

+{

+    if (getRegion())

+    {

+        return getRegion()->requestPostCapability(capName, postData, cbSuccess, cbFailure);

+    }

+    return false;

+}

+

+bool LLAgent::requestGetCapability(const std::string &capName, httpCallback_t cbSuccess, httpCallback_t cbFailure)

+{

+    if (getRegion())

+    {

+        return getRegion()->requestGetCapability(capName, cbSuccess, cbFailure);

+    }

+    return false;

+}

+

+bool LLAgent::getAdminOverride() const

+{

+    return mAgentAccess->getAdminOverride();

+}

+

+void LLAgent::setMaturity(char text)

+{

+    mAgentAccess->setMaturity(text);

+}

+

+void LLAgent::setAdminOverride(bool b)

+{

+    mAgentAccess->setAdminOverride(b);

+}

+

+void LLAgent::setGodLevel(U8 god_level)

+{

+    mAgentAccess->setGodLevel(god_level);

+    mGodLevelChangeSignal(god_level);

+}

+

+LLAgent::god_level_change_slot_t LLAgent::registerGodLevelChanageListener(god_level_change_callback_t pGodLevelChangeCallback)

+{

+    return mGodLevelChangeSignal.connect(pGodLevelChangeCallback);

+}

+

+const LLAgentAccess& LLAgent::getAgentAccess()

+{

+    return *mAgentAccess;

+}

+

+bool LLAgent::validateMaturity(const LLSD& newvalue)

+{

+    return mAgentAccess->canSetMaturity(newvalue.asInteger());

+}

+

+void LLAgent::handleMaturity(const LLSD &pNewValue)

+{

+    sendMaturityPreferenceToServer(static_cast<U8>(pNewValue.asInteger()));

+}

+

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

+

+//*TODO remove, is not used anywhere as of August 20, 2009

+void LLAgent::buildFullnameAndTitle(std::string& name) const

+{

+    if (isGroupMember())

+    {

+        name = mGroupTitle;

+        name += ' ';

+    }

+    else

+    {

+        name.erase(0, name.length());

+    }

+

+    if (isAgentAvatarValid())

+    {

+        name += gAgentAvatarp->getFullname();

+    }

+}

+

+bool LLAgent::isInGroup(const LLUUID& group_id, bool ignore_god_mode /* false */) const

+{

+    if (!ignore_god_mode && isGodlike())

+        return true;

+

+    U32 count = mGroups.size();

+    for(U32 i = 0; i < count; ++i)

+    {

+        if(mGroups[i].mID == group_id)

+        {

+            return true;

+        }

+    }

+    return false;

+}

+

+// This implementation should mirror LLAgentInfo::hasPowerInGroup

+bool LLAgent::hasPowerInGroup(const LLUUID& group_id, U64 power) const

+{

+    if (isGodlikeWithoutAdminMenuFakery())

+        return true;

+

+    // GP_NO_POWERS can also mean no power is enough to grant an ability.

+    if (GP_NO_POWERS == power) return false;

+

+    U32 count = mGroups.size();

+    for(U32 i = 0; i < count; ++i)

+    {

+        if(mGroups[i].mID == group_id)

+        {

+            return (bool)((mGroups[i].mPowers & power) > 0);

+        }

+    }

+    return false;

+}

+

+bool LLAgent::hasPowerInActiveGroup(U64 power) const

+{

+    return (mGroupID.notNull() && (hasPowerInGroup(mGroupID, power)));

+}

+

+U64 LLAgent::getPowerInGroup(const LLUUID& group_id) const

+{

+    if (isGodlike())

+        return GP_ALL_POWERS;

+

+    U32 count = mGroups.size();

+    for(U32 i = 0; i < count; ++i)

+    {

+        if(mGroups[i].mID == group_id)

+        {

+            return (mGroups[i].mPowers);

+        }

+    }

+

+    return GP_NO_POWERS;

+}

+

+bool LLAgent::getGroupData(const LLUUID& group_id, LLGroupData& data) const

+{

+    S32 count = mGroups.size();

+    for(S32 i = 0; i < count; ++i)

+    {

+        if(mGroups[i].mID == group_id)

+        {

+            data = mGroups[i];

+            return true;

+        }

+    }

+    return false;

+}

+

+S32 LLAgent::getGroupContribution(const LLUUID& group_id) const

+{

+    S32 count = mGroups.size();

+    for(S32 i = 0; i < count; ++i)

+    {

+        if(mGroups[i].mID == group_id)

+        {

+            S32 contribution = mGroups[i].mContribution;

+            return contribution;

+        }

+    }

+    return 0;

+}

+

+bool LLAgent::setGroupContribution(const LLUUID& group_id, S32 contribution)

+{

+    S32 count = mGroups.size();

+    for(S32 i = 0; i < count; ++i)

+    {

+        if(mGroups[i].mID == group_id)

+        {

+            mGroups[i].mContribution = contribution;

+            LLMessageSystem* msg = gMessageSystem;

+            msg->newMessage("SetGroupContribution");

+            msg->nextBlock("AgentData");

+            msg->addUUID("AgentID", gAgentID);

+            msg->addUUID("SessionID", gAgentSessionID);

+            msg->nextBlock("Data");

+            msg->addUUID("GroupID", group_id);

+            msg->addS32("Contribution", contribution);

+            sendReliableMessage();

+            return true;

+        }

+    }

+    return false;

+}

+

+bool LLAgent::setUserGroupFlags(const LLUUID& group_id, bool accept_notices, bool list_in_profile)

+{

+    S32 count = mGroups.size();

+    for(S32 i = 0; i < count; ++i)

+    {

+        if(mGroups[i].mID == group_id)

+        {

+            mGroups[i].mAcceptNotices = accept_notices;

+            mGroups[i].mListInProfile = list_in_profile;

+            LLMessageSystem* msg = gMessageSystem;

+            msg->newMessage("SetGroupAcceptNotices");

+            msg->nextBlock("AgentData");

+            msg->addUUID("AgentID", gAgentID);

+            msg->addUUID("SessionID", gAgentSessionID);

+            msg->nextBlock("Data");

+            msg->addUUID("GroupID", group_id);

+            msg->addBOOL("AcceptNotices", accept_notices);

+            msg->nextBlock("NewData");

+            msg->addBOOL("ListInProfile", list_in_profile);

+            sendReliableMessage();

+            return true;

+        }

+    }

+    return false;

+}

+

+bool LLAgent::canJoinGroups() const

+{

+    return (S32)mGroups.size() < LLAgentBenefitsMgr::current().getGroupMembershipLimit();

+}

+

+LLQuaternion LLAgent::getHeadRotation()

+{

+    if (!isAgentAvatarValid() || !gAgentAvatarp->mPelvisp || !gAgentAvatarp->mHeadp)

+    {

+        return LLQuaternion::DEFAULT;

+    }

+

+    if (!gAgentCamera.cameraMouselook())

+    {

+        return gAgentAvatarp->getRotation();

+    }

+

+    // We must be in mouselook

+    LLVector3 look_dir( LLViewerCamera::getInstance()->getAtAxis() );

+    LLVector3 up = look_dir % mFrameAgent.getLeftAxis();

+    LLVector3 left = up % look_dir;

+

+    LLQuaternion rot(look_dir, left, up);

+    if (gAgentAvatarp->getParent())

+    {

+        rot = rot * ~gAgentAvatarp->getParent()->getRotation();

+    }

+

+    return rot;

+}

+

+void LLAgent::sendAnimationRequests(const std::vector<LLUUID> &anim_ids, EAnimRequest request)

+{

+    if (gAgentID.isNull())

+    {

+        return;

+    }

+

+    S32 num_valid_anims = 0;

+

+    LLMessageSystem* msg = gMessageSystem;

+    msg->newMessageFast(_PREHASH_AgentAnimation);

+    msg->nextBlockFast(_PREHASH_AgentData);

+    msg->addUUIDFast(_PREHASH_AgentID, getID());

+    msg->addUUIDFast(_PREHASH_SessionID, getSessionID());

+

+    for (const LLUUID& uuid : anim_ids)

+    {

+        if (uuid.notNull())

+        {

+            msg->nextBlockFast(_PREHASH_AnimationList);

+            msg->addUUIDFast(_PREHASH_AnimID, uuid);

+            msg->addBOOLFast(_PREHASH_StartAnim, request == ANIM_REQUEST_START);

+            num_valid_anims++;

+        }

+    }

+

+    msg->nextBlockFast(_PREHASH_PhysicalAvatarEventList);

+    msg->addBinaryDataFast(_PREHASH_TypeData, NULL, 0);

+    if (num_valid_anims)

+    {

+        sendReliableMessage();

+    }

+}

+

+void LLAgent::sendAnimationRequest(const LLUUID &anim_id, EAnimRequest request)

+{

+    if (gAgentID.isNull() || anim_id.isNull() || !mRegionp)

+    {

+        return;

+    }

+

+    LLMessageSystem* msg = gMessageSystem;

+    msg->newMessageFast(_PREHASH_AgentAnimation);

+    msg->nextBlockFast(_PREHASH_AgentData);

+    msg->addUUIDFast(_PREHASH_AgentID, getID());

+    msg->addUUIDFast(_PREHASH_SessionID, getSessionID());

+

+    msg->nextBlockFast(_PREHASH_AnimationList);

+    msg->addUUIDFast(_PREHASH_AnimID, anim_id);

+    msg->addBOOLFast(_PREHASH_StartAnim, request == ANIM_REQUEST_START);

+

+    msg->nextBlockFast(_PREHASH_PhysicalAvatarEventList);

+    msg->addBinaryDataFast(_PREHASH_TypeData, NULL, 0);

+    sendReliableMessage();

+}

+

+// Send a message to the region to stop the NULL animation state

+// This will reset animation state overrides for the agent.

+void LLAgent::sendAnimationStateReset()

+{

+    if (gAgentID.isNull() || !mRegionp)

+    {

+        return;

+    }

+

+    LLMessageSystem* msg = gMessageSystem;

+    msg->newMessageFast(_PREHASH_AgentAnimation);

+    msg->nextBlockFast(_PREHASH_AgentData);

+    msg->addUUIDFast(_PREHASH_AgentID, getID());

+    msg->addUUIDFast(_PREHASH_SessionID, getSessionID());

+

+    msg->nextBlockFast(_PREHASH_AnimationList);

+    msg->addUUIDFast(_PREHASH_AnimID, LLUUID::null );

+    msg->addBOOLFast(_PREHASH_StartAnim, false);

+

+    msg->nextBlockFast(_PREHASH_PhysicalAvatarEventList);

+    msg->addBinaryDataFast(_PREHASH_TypeData, NULL, 0);

+    sendReliableMessage();

+}

+

+

+// Send a message to the region to revoke sepecified permissions on ALL scripts in the region

+// If the target is an object in the region, permissions in scripts on that object are cleared.

+// If it is the region ID, all scripts clear the permissions for this agent

+void LLAgent::sendRevokePermissions(const LLUUID & target, U32 permissions)

+{

+    // Currently only the bits for SCRIPT_PERMISSION_TRIGGER_ANIMATION and SCRIPT_PERMISSION_OVERRIDE_ANIMATIONS

+    // are supported by the server.  Sending any other bits will cause the message to be dropped without changing permissions

+

+    if (gAgentID.notNull() && gMessageSystem)

+    {

+        LLMessageSystem* msg = gMessageSystem;

+        msg->newMessageFast(_PREHASH_RevokePermissions);

+        msg->nextBlockFast(_PREHASH_AgentData);

+        msg->addUUIDFast(_PREHASH_AgentID, getID());        // Must be our ID

+        msg->addUUIDFast(_PREHASH_SessionID, getSessionID());

+

+        msg->nextBlockFast(_PREHASH_Data);

+        msg->addUUIDFast(_PREHASH_ObjectID, target);        // Must be in the region

+        msg->addS32Fast(_PREHASH_ObjectPermissions, (S32) permissions);

+

+        sendReliableMessage();

+    }

+}

+

+void LLAgent::sendWalkRun(bool running)

+{

+    LLMessageSystem* msgsys = gMessageSystem;

+    if (msgsys)

+    {

+        msgsys->newMessageFast(_PREHASH_SetAlwaysRun);

+        msgsys->nextBlockFast(_PREHASH_AgentData);

+        msgsys->addUUIDFast(_PREHASH_AgentID, getID());

+        msgsys->addUUIDFast(_PREHASH_SessionID, getSessionID());

+        msgsys->addBOOLFast(_PREHASH_AlwaysRun, bool(running) );

+        sendReliableMessage();

+    }

+}

+

+void LLAgent::friendsChanged()

+{

+    LLCollectProxyBuddies collector;

+    LLAvatarTracker::instance().applyFunctor(collector);

+    mProxyForAgents = collector.mProxy;

+}

+

+bool LLAgent::isGrantedProxy(const LLPermissions& perm)

+{

+    return (mProxyForAgents.count(perm.getOwner()) > 0);

+}

+

+bool LLAgent::allowOperation(PermissionBit op,

+                             const LLPermissions& perm,

+                             U64 group_proxy_power,

+                             U8 god_minimum)

+{

+    // Check god level.

+    if (getGodLevel() >= god_minimum) return true;

+

+    if (!perm.isOwned()) return false;

+

+    // A group member with group_proxy_power can act as owner.

+    bool is_group_owned;

+    LLUUID owner_id;

+    perm.getOwnership(owner_id, is_group_owned);

+    LLUUID group_id(perm.getGroup());

+    LLUUID agent_proxy(getID());

+

+    if (is_group_owned)

+    {

+        if (hasPowerInGroup(group_id, group_proxy_power))

+        {

+            // Let the member assume the group's id for permission requests.

+            agent_proxy = owner_id;

+        }

+    }

+    else

+    {

+        // Check for granted mod permissions.

+        if ((PERM_OWNER != op) && isGrantedProxy(perm))

+        {

+            agent_proxy = owner_id;

+        }

+    }

+

+    // This is the group id to use for permission requests.

+    // Only group members may use this field.

+    LLUUID group_proxy = LLUUID::null;

+    if (group_id.notNull() && isInGroup(group_id))

+    {

+        group_proxy = group_id;

+    }

+

+    // We now have max ownership information.

+    if (PERM_OWNER == op)

+    {

+        // This this was just a check for ownership, we can now return the answer.

+        return (agent_proxy == owner_id);

+    }

+

+    return perm.allowOperationBy(op, agent_proxy, group_proxy);

+}

+

+const LLColor4 &LLAgent::getEffectColor()

+{

+    return *mEffectColor;

+}

+

+void LLAgent::setEffectColor(const LLColor4 &color)

+{

+    *mEffectColor = color;

+}

+

+void LLAgent::initOriginGlobal(const LLVector3d &origin_global)

+{

+    mAgentOriginGlobal = origin_global;

+}

+

+bool LLAgent::leftButtonGrabbed() const

+{

+    const bool camera_mouse_look = gAgentCamera.cameraMouselook();

+    return (!camera_mouse_look && mControlsTakenCount[CONTROL_LBUTTON_DOWN_INDEX] > 0)

+        || (camera_mouse_look && mControlsTakenCount[CONTROL_ML_LBUTTON_DOWN_INDEX] > 0)

+        || (!camera_mouse_look && mControlsTakenPassedOnCount[CONTROL_LBUTTON_DOWN_INDEX] > 0)

+        || (camera_mouse_look && mControlsTakenPassedOnCount[CONTROL_ML_LBUTTON_DOWN_INDEX] > 0);

+}

+

+bool LLAgent::rotateGrabbed() const

+{

+    return (mControlsTakenCount[CONTROL_YAW_POS_INDEX] > 0)

+        || (mControlsTakenCount[CONTROL_YAW_NEG_INDEX] > 0);

+}

+

+bool LLAgent::forwardGrabbed() const

+{

+    return (mControlsTakenCount[CONTROL_AT_POS_INDEX] > 0);

+}

+

+bool LLAgent::backwardGrabbed() const

+{

+    return (mControlsTakenCount[CONTROL_AT_NEG_INDEX] > 0);

+}

+

+bool LLAgent::upGrabbed() const

+{

+    return (mControlsTakenCount[CONTROL_UP_POS_INDEX] > 0);

+}

+

+bool LLAgent::downGrabbed() const

+{

+    return (mControlsTakenCount[CONTROL_UP_NEG_INDEX] > 0);

+}

+

+void update_group_floaters(const LLUUID& group_id)

+{

+

+    LLGroupActions::refresh(group_id);

+    //*TODO Implement group update for Profile View

+    // still actual as of July 31, 2009 (DZ)

+

+    gAgent.fireEvent(new LLOldEvents::LLEvent(&gAgent, "new group"), "");

+}

+

+// static

+void LLAgent::processAgentDropGroup(LLMessageSystem *msg, void **)

+{

+    LLUUID  agent_id;

+    msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_AgentID, agent_id );

+

+    if (agent_id != gAgentID)

+    {

+        LL_WARNS() << "processAgentDropGroup for agent other than me" << LL_ENDL;

+        return;

+    }

+

+    LLUUID  group_id;

+    msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_GroupID, group_id );

+

+    // Remove the group if it already exists remove it and add the new data to pick up changes.

+    LLGroupData gd;

+    gd.mID = group_id;

+    std::vector<LLGroupData>::iterator found_it = std::find(gAgent.mGroups.begin(), gAgent.mGroups.end(), gd);

+    if (found_it != gAgent.mGroups.end())

+    {

+        gAgent.mGroups.erase(found_it);

+        if (gAgent.getGroupID() == group_id)

+        {

+            gAgent.mGroupID.setNull();

+            gAgent.mGroupPowers = 0;

+            gAgent.mGroupName.clear();

+            gAgent.mGroupTitle.clear();

+        }

+

+        // refresh all group information

+        gAgent.sendAgentDataUpdateRequest();

+

+        LLGroupMgr::getInstance()->clearGroupData(group_id);

+        // close the floater for this group, if any.

+        LLGroupActions::closeGroup(group_id);

+    }

+    else

+    {

+        LL_WARNS() << "processAgentDropGroup, agent is not part of group " << group_id << LL_ENDL;

+    }

+}

+

+class LLAgentDropGroupViewerNode : public LLHTTPNode

+{

+    virtual void post(

+        LLHTTPNode::ResponsePtr response,

+        const LLSD& context,

+        const LLSD& input) const

+    {

+

+        if (

+            !input.isMap() ||

+            !input.has("body") )

+        {

+            //what to do with badly formed message?

+            response->extendedResult(HTTP_BAD_REQUEST, LLSD("Invalid message parameters"));

+        }

+

+        LLSD body = input["body"];

+        if ( body.has("body") )

+        {

+            //stupid message system doubles up the "body"s

+            body = body["body"];

+        }

+

+        if (

+            body.has("AgentData") &&

+            body["AgentData"].isArray() &&

+            body["AgentData"][0].isMap() )

+        {

+            LL_INFOS() << "VALID DROP GROUP" << LL_ENDL;

+

+            //there is only one set of data in the AgentData block

+            LLSD agent_data = body["AgentData"][0];

+            LLUUID agent_id;

+            LLUUID group_id;

+

+            agent_id = agent_data["AgentID"].asUUID();

+            group_id = agent_data["GroupID"].asUUID();

+

+            if (agent_id != gAgentID)

+            {

+                LL_WARNS()

+                    << "AgentDropGroup for agent other than me" << LL_ENDL;

+

+                response->notFound();

+                return;

+            }

+

+            // Remove the group if it already exists remove it

+            // and add the new data to pick up changes.

+            LLGroupData gd;

+            gd.mID = group_id;

+            std::vector<LLGroupData>::iterator found_it = std::find(gAgent.mGroups.begin(), gAgent.mGroups.end(), gd);

+            if (found_it != gAgent.mGroups.end())

+            {

+                gAgent.mGroups.erase(found_it);

+                if (gAgent.getGroupID() == group_id)

+                {

+                    gAgent.mGroupID.setNull();

+                    gAgent.mGroupPowers = 0;

+                    gAgent.mGroupName.clear();

+                    gAgent.mGroupTitle.clear();

+                }

+

+                // refresh all group information

+                gAgent.sendAgentDataUpdateRequest();

+

+                LLGroupMgr::getInstance()->clearGroupData(group_id);

+                // close the floater for this group, if any.

+                LLGroupActions::closeGroup(group_id);

+            }

+            else

+            {

+                LL_WARNS()

+                    << "AgentDropGroup, agent is not part of group "

+                    << group_id << LL_ENDL;

+            }

+

+            response->result(LLSD());

+        }

+        else

+        {

+            //what to do with badly formed message?

+            response->extendedResult(HTTP_BAD_REQUEST, LLSD("Invalid message parameters"));

+        }

+    }

+};

+

+LLHTTPRegistration<LLAgentDropGroupViewerNode>

+    gHTTPRegistrationAgentDropGroupViewerNode(

+        "/message/AgentDropGroup");

+

+// static

+void LLAgent::processAgentGroupDataUpdate(LLMessageSystem *msg, void **)

+{

+    LLUUID  agent_id;

+

+    msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_AgentID, agent_id );

+

+    if (agent_id != gAgentID)

+    {

+        LL_WARNS() << "processAgentGroupDataUpdate for agent other than me" << LL_ENDL;

+        return;

+    }

+

+    S32 count = msg->getNumberOfBlocksFast(_PREHASH_GroupData);

+    LLGroupData group;

+    bool need_floater_update = false;

+    for(S32 i = 0; i < count; ++i)

+    {

+        msg->getUUIDFast(_PREHASH_GroupData, _PREHASH_GroupID, group.mID, i);

+        msg->getUUIDFast(_PREHASH_GroupData, _PREHASH_GroupInsigniaID, group.mInsigniaID, i);

+        msg->getU64(_PREHASH_GroupData, "GroupPowers", group.mPowers, i);

+        msg->getBOOL(_PREHASH_GroupData, "AcceptNotices", group.mAcceptNotices, i);

+        msg->getS32(_PREHASH_GroupData, "Contribution", group.mContribution, i);

+        msg->getStringFast(_PREHASH_GroupData, _PREHASH_GroupName, group.mName, i);

+

+        if(group.mID.notNull())

+        {

+            need_floater_update = true;

+            // Remove the group if it already exists remove it and add the new data to pick up changes.

+            std::vector<LLGroupData>::iterator found_it = std::find(gAgent.mGroups.begin(), gAgent.mGroups.end(), group);

+            if (found_it != gAgent.mGroups.end())

+            {

+                gAgent.mGroups.erase(found_it);

+            }

+            gAgent.mGroups.push_back(group);

+        }

+        if (need_floater_update)

+        {

+            update_group_floaters(group.mID);

+        }

+    }

+

+}

+

+class LLAgentGroupDataUpdateViewerNode : public LLHTTPNode

+{

+    virtual void post(

+        LLHTTPNode::ResponsePtr response,

+        const LLSD& context,

+        const LLSD& input) const

+    {

+        LLSD body = input["body"];

+        if(body.has("body"))

+            body = body["body"];

+        LLUUID agent_id = body["AgentData"][0]["AgentID"].asUUID();

+

+        if (agent_id != gAgentID)

+        {

+            LL_WARNS() << "processAgentGroupDataUpdate for agent other than me" << LL_ENDL;

+            return;

+        }

+

+        LLSD group_data = body["GroupData"];

+

+        LLSD::array_iterator iter_group =

+            group_data.beginArray();

+        LLSD::array_iterator end_group =

+            group_data.endArray();

+        int group_index = 0;

+        for(; iter_group != end_group; ++iter_group)

+        {

+

+            LLGroupData group;

+            bool need_floater_update = false;

+

+            group.mID = (*iter_group)["GroupID"].asUUID();

+            group.mPowers = ll_U64_from_sd((*iter_group)["GroupPowers"]);

+            group.mAcceptNotices = (*iter_group)["AcceptNotices"].asBoolean();

+            group.mListInProfile = body["NewGroupData"][group_index]["ListInProfile"].asBoolean();

+            group.mInsigniaID = (*iter_group)["GroupInsigniaID"].asUUID();

+            group.mName = (*iter_group)["GroupName"].asString();

+            group.mContribution = (*iter_group)["Contribution"].asInteger();

+

+            group_index++;

+

+            if(group.mID.notNull())

+            {

+                need_floater_update = true;

+                // Remove the group if it already exists remove it and add the new data to pick up changes.

+                std::vector<LLGroupData>::iterator found_it = std::find(gAgent.mGroups.begin(), gAgent.mGroups.end(), group);

+                if (found_it != gAgent.mGroups.end())

+                {

+                    gAgent.mGroups.erase(found_it);

+                }

+                gAgent.mGroups.push_back(group);

+            }

+            if (need_floater_update)

+            {

+                update_group_floaters(group.mID);

+            }

+        }

+    }

+};

+

+LLHTTPRegistration<LLAgentGroupDataUpdateViewerNode >

+    gHTTPRegistrationAgentGroupDataUpdateViewerNode ("/message/AgentGroupDataUpdate");

+

+// static

+void LLAgent::processAgentDataUpdate(LLMessageSystem *msg, void **)

+{

+    LLUUID  agent_id;

+

+    msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_AgentID, agent_id );

+

+    if (agent_id != gAgentID)

+    {

+        LL_WARNS() << "processAgentDataUpdate for agent other than me" << LL_ENDL;

+        return;

+    }

+

+    msg->getStringFast(_PREHASH_AgentData, _PREHASH_GroupTitle, gAgent.mGroupTitle);

+    LLUUID active_id;

+    msg->getUUIDFast(_PREHASH_AgentData, _PREHASH_ActiveGroupID, active_id);

+

+

+    if(active_id.notNull())

+    {

+        gAgent.mGroupID = active_id;

+        msg->getU64(_PREHASH_AgentData, "GroupPowers", gAgent.mGroupPowers);

+        msg->getString(_PREHASH_AgentData, _PREHASH_GroupName, gAgent.mGroupName);

+    }

+    else

+    {

+        gAgent.mGroupID.setNull();

+        gAgent.mGroupPowers = 0;

+        gAgent.mGroupName.clear();

+    }

+

+    update_group_floaters(active_id);

+}

+

+// static

+void LLAgent::processScriptControlChange(LLMessageSystem *msg, void **)

+{

+    S32 block_count = msg->getNumberOfBlocks("Data");

+    for (S32 block_index = 0; block_index < block_count; block_index++)

+    {

+        bool take_controls;

+        U32 controls;

+        bool passon;

+        U32 i;

+        msg->getBOOL("Data", "TakeControls", take_controls, block_index);

+        if (take_controls)

+        {

+            // take controls

+            msg->getU32("Data", "Controls", controls, block_index );

+            msg->getBOOL("Data", "PassToAgent", passon, block_index );

+            for (i = 0; i < TOTAL_CONTROLS; i++)

+            {

+                if (controls & ( 1 << i))

+                {

+                    if (passon)

+                    {

+                        gAgent.mControlsTakenPassedOnCount[i]++;

+                    }

+                    else

+                    {

+                        gAgent.mControlsTakenCount[i]++;

+                    }

+                }

+            }

+        }

+        else

+        {

+            // release controls

+            msg->getU32("Data", "Controls", controls, block_index );

+            msg->getBOOL("Data", "PassToAgent", passon, block_index );

+            for (i = 0; i < TOTAL_CONTROLS; i++)

+            {

+                if (controls & ( 1 << i))

+                {

+                    if (passon)

+                    {

+                        gAgent.mControlsTakenPassedOnCount[i]--;

+                        if (gAgent.mControlsTakenPassedOnCount[i] < 0)

+                        {

+                            gAgent.mControlsTakenPassedOnCount[i] = 0;

+                        }

+                    }

+                    else

+                    {

+                        gAgent.mControlsTakenCount[i]--;

+                        if (gAgent.mControlsTakenCount[i] < 0)

+                        {

+                            gAgent.mControlsTakenCount[i] = 0;

+                        }

+                    }

+                }

+            }

+        }

+    }

+}

+

+/*

+// static

+void LLAgent::processControlTake(LLMessageSystem *msg, void **)

+{

+    U32 controls;

+    msg->getU32("Data", "Controls", controls );

+    U32 passon;

+    msg->getBOOL("Data", "PassToAgent", passon );

+

+    S32 i;

+    S32 total_count = 0;

+    for (i = 0; i < TOTAL_CONTROLS; i++)

+    {

+        if (controls & ( 1 << i))

+        {

+            if (passon)

+            {

+                gAgent.mControlsTakenPassedOnCount[i]++;

+            }

+            else

+            {

+                gAgent.mControlsTakenCount[i]++;

+            }

+            total_count++;

+        }

+    }

+

+    // Any control taken?  If so, might be first time.

+    if (total_count > 0)

+    {

+        LLFirstUse::useOverrideKeys();

+    }

+}

+

+// static

+void LLAgent::processControlRelease(LLMessageSystem *msg, void **)

+{

+    U32 controls;

+    msg->getU32("Data", "Controls", controls );

+    U32 passon;

+    msg->getBOOL("Data", "PassToAgent", passon );

+

+    S32 i;

+    for (i = 0; i < TOTAL_CONTROLS; i++)

+    {

+        if (controls & ( 1 << i))

+        {

+            if (passon)

+            {

+                gAgent.mControlsTakenPassedOnCount[i]--;

+                if (gAgent.mControlsTakenPassedOnCount[i] < 0)

+                {

+                    gAgent.mControlsTakenPassedOnCount[i] = 0;

+                }

+            }

+            else

+            {

+                gAgent.mControlsTakenCount[i]--;

+                if (gAgent.mControlsTakenCount[i] < 0)

+                {

+                    gAgent.mControlsTakenCount[i] = 0;

+                }

+            }

+        }

+    }

+}

+*/

+

+bool LLAgent::anyControlGrabbed() const

+{

+    for (U32 i = 0; i < TOTAL_CONTROLS; i++)

+    {

+        if (gAgent.mControlsTakenCount[i] > 0)

+            return true;

+        if (gAgent.mControlsTakenPassedOnCount[i] > 0)

+            return true;

+    }

+    return false;

+}

+

+bool LLAgent::isControlGrabbed(S32 control_index) const

+{

+    return mControlsTakenCount[control_index] > 0;

+}

+

+void LLAgent::forceReleaseControls()

+{

+    gMessageSystem->newMessage("ForceScriptControlRelease");

+    gMessageSystem->nextBlock("AgentData");

+    gMessageSystem->addUUID("AgentID", getID());

+    gMessageSystem->addUUID("SessionID", getSessionID());

+    sendReliableMessage();

+}

+

+void LLAgent::setHomePosRegion( const U64& region_handle, const LLVector3& pos_region)

+{

+    mHaveHomePosition = true;

+    mHomeRegionHandle = region_handle;

+    mHomePosRegion = pos_region;

+}

+

+bool LLAgent::getHomePosGlobal( LLVector3d* pos_global )

+{

+    if(!mHaveHomePosition)

+    {

+        return false;

+    }

+    F32 x = 0;

+    F32 y = 0;

+    from_region_handle( mHomeRegionHandle, &x, &y);

+    pos_global->setVec( x + mHomePosRegion.mV[VX], y + mHomePosRegion.mV[VY], mHomePosRegion.mV[VZ] );

+    return true;

+}

+

+bool LLAgent::isInHomeRegion()

+{

+    if(!mHaveHomePosition)

+    {

+        return false;

+    }

+    if (!getRegion())

+    {

+        return false;

+    }

+    if (getRegion()->getHandle() != mHomeRegionHandle)

+    {

+        return false;

+    }

+    return true;

+}

+

+void LLAgent::clearVisualParams(void *data)

+{

+    if (isAgentAvatarValid())

+    {

+        gAgentAvatarp->clearVisualParamWeights();

+        gAgentAvatarp->updateVisualParams();

+    }

+}

+

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

+// Teleport

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

+

+// teleportCore() - stuff to do on any teleport

+// protected

+bool LLAgent::teleportCore(bool is_local)

+{

+    LL_DEBUGS("Teleport") << "In teleport core" << LL_ENDL;

+    if ((TELEPORT_NONE != mTeleportState) && (mTeleportState != TELEPORT_PENDING))

+    {

+        LL_WARNS() << "Attempt to teleport when already teleporting." << LL_ENDL;

+        return false;

+    }

+

+    // force stand up and stop a sitting animation (if any), see MAINT-3969

+    if (isAgentAvatarValid() && gAgentAvatarp->getParent() && gAgentAvatarp->isSitting())

+    {

+        gAgentAvatarp->getOffObject();

+    }

+

+#if 0

+    // This should not exist. It has been added, removed, added, and now removed again.

+    // This change needs to come from the simulator. Otherwise, the agent ends up out of

+    // sync with other viewers. Discuss in DEV-14145/VWR-6744 before reenabling.

+

+    // Stop all animation before actual teleporting

+        if (isAgentAvatarValid())

+    {

+        for ( LLVOAvatar::AnimIterator anim_it= gAgentAvatarp->mPlayingAnimations.begin();

+              anim_it != gAgentAvatarp->mPlayingAnimations.end();

+              ++anim_it)

+               {

+                       gAgentAvatarp->stopMotion(anim_it->first);

+               }

+               gAgentAvatarp->processAnimationStateChanges();

+       }

+#endif

+

+    // Don't call LLFirstUse::useTeleport because we don't know

+    // yet if the teleport will succeed.  Look in

+    // process_teleport_location_reply

+

+    // hide land floater too - it'll be out of date

+    LLFloaterReg::hideInstance("about_land");

+

+    // hide the Region/Estate floater

+    LLFloaterReg::hideInstance("region_info");

+

+    LLViewerParcelMgr::getInstance()->deselectLand();

+    LLViewerMediaFocus::getInstance()->clearFocus();

+

+    // Close all pie menus, deselect land, etc.

+    // Don't change the camera until we know teleport succeeded. JC

+    gAgentCamera.resetView(false);

+

+    // local logic

+    add(LLStatViewer::TELEPORT, 1);

+    if (is_local)

+    {

+        LL_INFOS("Teleport") << "Setting teleport state to TELEPORT_LOCAL" << LL_ENDL;

+        gAgent.setTeleportState( LLAgent::TELEPORT_LOCAL );

+    }

+    else

+    {

+        gTeleportDisplay = true;

+        LL_INFOS("Teleport") << "Non-local, setting teleport state to TELEPORT_START" << LL_ENDL;

+        gAgent.setTeleportState( LLAgent::TELEPORT_START );

+    }

+    make_ui_sound("UISndTeleportOut");

+

+    // MBW -- Let the voice client know a teleport has begun so it can leave the existing channel.

+    // This was breaking the case of teleporting within a single sim.  Backing it out for now.

+//  LLVoiceClient::getInstance()->leaveChannel();

+

+    return true;

+}

+

+bool LLAgent::hasRestartableFailedTeleportRequest()

+{

+    return ((mTeleportRequest != NULL) && (mTeleportRequest->getStatus() == LLTeleportRequest::kFailed) &&

+        mTeleportRequest->canRestartTeleport());

+}

+

+void LLAgent::restartFailedTeleportRequest()

+{

+    LL_INFOS("Teleport") << "Agent wishes to restart failed teleport." << LL_ENDL;

+    if (hasRestartableFailedTeleportRequest())

+    {

+        mTeleportRequest->setStatus(LLTeleportRequest::kRestartPending);

+        startTeleportRequest();

+    }

+}

+

+void LLAgent::clearTeleportRequest()

+{

+    if(LLVoiceClient::instanceExists())

+    {

+        LLVoiceClient::getInstance()->setHidden(false);

+    }

+    mTeleportRequest.reset();

+    mTPNeedsNeabyChatSeparator = false;

+}

+

+void LLAgent::setMaturityRatingChangeDuringTeleport(U8 pMaturityRatingChange)

+{

+    mIsMaturityRatingChangingDuringTeleport = true;

+    mMaturityRatingChange = pMaturityRatingChange;

+}

+

+void LLAgent::sheduleTeleportIM()

+{

+    // is supposed to be called during teleport so we are still waiting for parcel

+    mTPNeedsNeabyChatSeparator = true;

+}

+

+bool LLAgent::hasPendingTeleportRequest()

+{

+    return ((mTeleportRequest != NULL) &&

+        ((mTeleportRequest->getStatus() == LLTeleportRequest::kPending) ||

+        (mTeleportRequest->getStatus() == LLTeleportRequest::kRestartPending)));

+}

+

+void LLAgent::startTeleportRequest()

+{

+    LL_INFOS("Telport") << "Agent handling start teleport request." << LL_ENDL;

+    if(LLVoiceClient::instanceExists())

+    {

+        LLVoiceClient::getInstance()->setHidden(true);

+    }

+    if (hasPendingTeleportRequest())

+    {

+        LLUIUsage::instance().logCommand("Agent.StartTeleportRequest");

+        mTeleportCanceled.reset();

+        if  (!isMaturityPreferenceSyncedWithServer())

+        {

+            gTeleportDisplay = true;

+            LL_INFOS("Teleport") << "Maturity preference not synced yet, setting teleport state to TELEPORT_PENDING" << LL_ENDL;

+            setTeleportState(TELEPORT_PENDING);

+        }

+        else

+        {

+            switch (mTeleportRequest->getStatus())

+            {

+            case LLTeleportRequest::kPending :

+                mTeleportRequest->setStatus(LLTeleportRequest::kStarted);

+                mTeleportRequest->startTeleport();

+                break;

+            case LLTeleportRequest::kRestartPending :

+                llassert(mTeleportRequest->canRestartTeleport());

+                mTeleportRequest->setStatus(LLTeleportRequest::kStarted);

+                mTeleportRequest->restartTeleport();

+                break;

+            default :

+                llassert(0);

+                break;

+            }

+        }

+    }

+}

+

+void LLAgent::handleTeleportFinished()

+{

+    LL_INFOS("Teleport") << "Agent handling teleport finished." << LL_ENDL;

+    if (mTPNeedsNeabyChatSeparator)

+    {

+        // parcel is ready at this point

+        addTPNearbyChatSeparator();

+        mTPNeedsNeabyChatSeparator = false;

+    }

+    clearTeleportRequest();

+    mTeleportCanceled.reset();

+    if (mIsMaturityRatingChangingDuringTeleport)

+    {

+        // notify user that the maturity preference has been changed

+        std::string maturityRating = LLViewerRegion::accessToString(mMaturityRatingChange);

+        LLStringUtil::toLower(maturityRating);

+        LLSD args;

+        args["RATING"] = maturityRating;

+        LLNotificationsUtil::add("PreferredMaturityChanged", args);

+        mIsMaturityRatingChangingDuringTeleport = false;

+    }

+

+    if (mRegionp)

+    {

+        if (mRegionp->capabilitiesReceived())

+        {

+            LL_DEBUGS("Teleport") << "capabilities have been received for region handle "

+                                  << mRegionp->getHandle()

+                                  << " id " << mRegionp->getRegionID()

+                                  << ", calling onCapabilitiesReceivedAfterTeleport()"

+                                  << LL_ENDL;

+            onCapabilitiesReceivedAfterTeleport();

+        }

+        else

+        {

+            LL_DEBUGS("Teleport") << "Capabilities not yet received for region handle "

+                                  << mRegionp->getHandle()

+                                  << " id " << mRegionp->getRegionID()

+                                  << LL_ENDL;

+            mRegionp->setCapabilitiesReceivedCallback(boost::bind(&LLAgent::onCapabilitiesReceivedAfterTeleport));

+        }

+    }

+    LLPerfStats::tunables.autoTuneTimeout = true;

+}

+

+void LLAgent::handleTeleportFailed()

+{

+    LL_WARNS("Teleport") << "Agent handling teleport failure!" << LL_ENDL;

+    if(LLVoiceClient::instanceExists())

+    {

+        LLVoiceClient::getInstance()->setHidden(false);

+    }

+

+    setTeleportState(LLAgent::TELEPORT_NONE);

+    // Unlock the UI if the progress bar has been shown.

+//     gViewerWindow->setShowProgress(false);

+//     gTeleportDisplay = false;

+

+    if (mTeleportRequest)

+    {

+        mTeleportRequest->setStatus(LLTeleportRequest::kFailed);

+    }

+    if (mIsMaturityRatingChangingDuringTeleport)

+    {

+        // notify user that the maturity preference has been changed

+        std::string maturityRating = LLViewerRegion::accessToString(mMaturityRatingChange);

+        LLStringUtil::toLower(maturityRating);

+        LLSD args;

+        args["RATING"] = maturityRating;

+        LLNotificationsUtil::add("PreferredMaturityChanged", args);

+        mIsMaturityRatingChangingDuringTeleport = false;

+    }

+

+    mTPNeedsNeabyChatSeparator = false;

+

+    LLPerfStats::tunables.autoTuneTimeout = true;

+}

+

+/*static*/

+void LLAgent::addTPNearbyChatSeparator()

+{

+    LLViewerRegion* agent_region = gAgent.getRegion();

+    LLParcel* agent_parcel = LLViewerParcelMgr::getInstance()->getAgentParcel();

+    if (!agent_region || !agent_parcel)

+    {

+        return;

+    }

+

+    LLFloaterIMNearbyChat* nearby_chat = LLFloaterReg::getTypedInstance<LLFloaterIMNearbyChat>("nearby_chat");

+    if (nearby_chat)

+    {

+        std::string location_name;

+        LLAgentUI::ELocationFormat format = LLAgentUI::LOCATION_FORMAT_NO_MATURITY;

+

+        // Might be better to provide slurl to chat

+        if (!LLAgentUI::buildLocationString(location_name, format))

+        {

+            location_name = "Teleport to new region"; // Shouldn't happen

+        }

+

+        LLChat chat;

+        chat.mFromName = location_name;

+        chat.mMuted = false;

+        chat.mFromID = LLUUID::null;

+        chat.mSourceType = CHAT_SOURCE_TELEPORT;

+        chat.mChatStyle = CHAT_STYLE_TELEPORT_SEP;

+        chat.mText = "";

+

+        LLSD args;

+        args["do_not_log"] = true;

+        nearby_chat->addMessage(chat, true, args);

+    }

+}

+

+/*static*/

+void LLAgent::onCapabilitiesReceivedAfterTeleport()

+{

+    if (gAgent.getRegion())

+    {

+        LL_DEBUGS("Teleport") << "running after capabilities received callback has been triggered, agent region "

+                              << gAgent.getRegion()->getHandle()

+                              << " id " << gAgent.getRegion()->getRegionID()

+                              << " name " << gAgent.getRegion()->getName()

+                              << LL_ENDL;

+    }

+    else

+    {

+        LL_WARNS("Teleport") << "called when agent region is null!" << LL_ENDL;

+    }

+

+    check_merchant_status();

+}

+

+

+void LLAgent::teleportRequest(

+    const U64& region_handle,

+    const LLVector3& pos_local,

+    bool look_at_from_camera)

+{

+    LLViewerRegion* regionp = getRegion();

+    if (regionp && teleportCore(region_handle == regionp->getHandle()))

+    {

+        LL_INFOS("Teleport") << "Sending TeleportLocationRequest: '" << region_handle << "':"

+                             << pos_local << LL_ENDL;

+        LLMessageSystem* msg = gMessageSystem;

+        msg->newMessage("TeleportLocationRequest");

+        msg->nextBlockFast(_PREHASH_AgentData);

+        msg->addUUIDFast(_PREHASH_AgentID, getID());

+        msg->addUUIDFast(_PREHASH_SessionID, getSessionID());

+        msg->nextBlockFast(_PREHASH_Info);

+        msg->addU64("RegionHandle", region_handle);

+        msg->addVector3("Position", pos_local);

+        LLVector3 look_at(0,1,0);

+        if (look_at_from_camera)

+        {

+            look_at = LLViewerCamera::getInstance()->getAtAxis();

+        }

+        msg->addVector3("LookAt", look_at);

+        sendReliableMessage();

+    }

+}

+

+// Landmark ID = LLUUID::null means teleport home

+void LLAgent::teleportViaLandmark(const LLUUID& landmark_asset_id)

+{

+    if (landmark_asset_id.isNull())

+    {

+        gAgentCamera.resetView();

+    }

+    mTeleportRequest = LLTeleportRequestPtr(new LLTeleportRequestViaLandmark(landmark_asset_id));

+    startTeleportRequest();

+}

+

+void LLAgent::doTeleportViaLandmark(const LLUUID& landmark_asset_id)

+{

+    LLViewerRegion *regionp = getRegion();

+    if(regionp && teleportCore())

+    {

+        LL_INFOS("Teleport") << "Sending TeleportLandmarkRequest. Current region handle " << regionp->getHandle()

+                             << " region id " << regionp->getRegionID()

+                             << " requested landmark id " << landmark_asset_id

+                             << LL_ENDL;

+

+        LLMessageSystem* msg = gMessageSystem;

+        msg->newMessageFast(_PREHASH_TeleportLandmarkRequest);

+        msg->nextBlockFast(_PREHASH_Info);

+        msg->addUUIDFast(_PREHASH_AgentID, getID());

+        msg->addUUIDFast(_PREHASH_SessionID, getSessionID());

+        msg->addUUIDFast(_PREHASH_LandmarkID, landmark_asset_id);

+        sendReliableMessage();

+    }

+}

+

+void LLAgent::teleportViaLure(const LLUUID& lure_id, bool godlike)

+{

+    mTeleportRequest = LLTeleportRequestPtr(new LLTeleportRequestViaLure(lure_id, godlike));

+    startTeleportRequest();

+}

+

+void LLAgent::doTeleportViaLure(const LLUUID& lure_id, bool godlike)

+{

+    LLViewerRegion* regionp = getRegion();

+    if(regionp && teleportCore())

+    {

+        U32 teleport_flags = 0x0;

+        if (godlike)

+        {

+            teleport_flags |= TELEPORT_FLAGS_VIA_GODLIKE_LURE;

+            teleport_flags |= TELEPORT_FLAGS_DISABLE_CANCEL;

+        }

+        else

+        {

+            teleport_flags |= TELEPORT_FLAGS_VIA_LURE;

+        }

+

+        LL_INFOS("Teleport") << "Sending TeleportLureRequest."

+                             << " Current region handle " << regionp->getHandle()

+                             << " region id " << regionp->getRegionID()

+                             << " lure id " << lure_id

+                             << LL_ENDL;

+        // send the message

+        LLMessageSystem* msg = gMessageSystem;

+        msg->newMessageFast(_PREHASH_TeleportLureRequest);

+        msg->nextBlockFast(_PREHASH_Info);

+        msg->addUUIDFast(_PREHASH_AgentID, getID());

+        msg->addUUIDFast(_PREHASH_SessionID, getSessionID());

+        msg->addUUIDFast(_PREHASH_LureID, lure_id);

+        // teleport_flags is a legacy field, now derived sim-side:

+        msg->addU32("TeleportFlags", teleport_flags);

+        sendReliableMessage();

+    }

+}

+

+

+// James Cook, July 28, 2005

+void LLAgent::teleportCancel()

+{

+    if (!hasPendingTeleportRequest())

+    {

+        LLViewerRegion* regionp = getRegion();

+        if(regionp)

+        {

+            LL_INFOS("Teleport") << "Sending TeleportCancel" << LL_ENDL;

+

+            // send the message

+            LLMessageSystem* msg = gMessageSystem;

+            msg->newMessage("TeleportCancel");

+            msg->nextBlockFast(_PREHASH_Info);

+            msg->addUUIDFast(_PREHASH_AgentID, getID());

+            msg->addUUIDFast(_PREHASH_SessionID, getSessionID());

+            sendReliableMessage();

+        }

+        mTeleportCanceled = mTeleportRequest;

+    }

+    clearTeleportRequest();

+    gAgent.setTeleportState( LLAgent::TELEPORT_NONE );

+}

+

+void LLAgent::restoreCanceledTeleportRequest()

+{

+    if (mTeleportCanceled != NULL)

+    {

+        LL_INFOS() << "Restoring canceled teleport request, setting state to TELEPORT_REQUESTED" << LL_ENDL;

+        gAgent.setTeleportState( LLAgent::TELEPORT_REQUESTED );

+        mTeleportRequest = mTeleportCanceled;

+        mTeleportCanceled.reset();

+        gTeleportDisplay = true;

+        gTeleportDisplayTimer.reset();

+    }

+}

+

+void LLAgent::teleportViaLocation(const LLVector3d& pos_global)

+{

+    mTeleportRequest = LLTeleportRequestPtr(new LLTeleportRequestViaLocation(pos_global));

+    startTeleportRequest();

+}

+

+void LLAgent::doTeleportViaLocation(const LLVector3d& pos_global)

+{

+    LLViewerRegion* regionp = getRegion();

+

+    if (!regionp)

+    {

+        return;

+    }

+

+    U64 handle = to_region_handle(pos_global);

+    LLSimInfo* info = LLWorldMap::getInstance()->simInfoFromHandle(handle);

+    if(regionp && info)

+    {

+        LLVector3d region_origin = info->getGlobalOrigin();

+        LLVector3 pos_local(

+            (F32)(pos_global.mdV[VX] - region_origin.mdV[VX]),

+            (F32)(pos_global.mdV[VY] - region_origin.mdV[VY]),

+            (F32)(pos_global.mdV[VZ]));

+        teleportRequest(handle, pos_local);

+    }

+    else if(regionp &&

+        teleportCore(regionp->getHandle() == to_region_handle_global((F32)pos_global.mdV[VX], (F32)pos_global.mdV[VY])))

+    {

+        // send the message

+        LLMessageSystem* msg = gMessageSystem;

+        msg->newMessageFast(_PREHASH_TeleportLocationRequest);

+        msg->nextBlockFast(_PREHASH_AgentData);

+        msg->addUUIDFast(_PREHASH_AgentID, getID());

+        msg->addUUIDFast(_PREHASH_SessionID, getSessionID());

+

+        msg->nextBlockFast(_PREHASH_Info);

+        F32 width = regionp->getWidth();

+        LLVector3 pos(fmod((F32)pos_global.mdV[VX], width),

+                      fmod((F32)pos_global.mdV[VY], width),

+                      (F32)pos_global.mdV[VZ]);

+        F32 region_x = (F32)(pos_global.mdV[VX]);

+        F32 region_y = (F32)(pos_global.mdV[VY]);

+        U64 region_handle = to_region_handle_global(region_x, region_y);

+        msg->addU64Fast(_PREHASH_RegionHandle, region_handle);

+        msg->addVector3Fast(_PREHASH_Position, pos);

+        pos.mV[VX] += 1;

+        msg->addVector3Fast(_PREHASH_LookAt, pos);

+

+        LL_WARNS("Teleport") << "Sending deprecated(?) TeleportLocationRequest."

+                             << " pos_global " << pos_global

+                             << " region_x " << region_x

+                             << " region_y " << region_y

+                             << " region_handle " << region_handle

+                             << LL_ENDL;

+

+        sendReliableMessage();

+    }

+}

+

+// Teleport to global position, but keep facing in the same direction

+void LLAgent::teleportViaLocationLookAt(const LLVector3d& pos_global)

+{

+    mTeleportRequest = LLTeleportRequestPtr(new LLTeleportRequestViaLocationLookAt(pos_global));

+    startTeleportRequest();

+}

+

+void LLAgent::doTeleportViaLocationLookAt(const LLVector3d& pos_global)

+{

+    mbTeleportKeepsLookAt = true;

+

+    if(!gAgentCamera.isfollowCamLocked())

+    {

+        gAgentCamera.setFocusOnAvatar(false, ANIMATE);  // detach camera form avatar, so it keeps direction

+    }

+

+    U64 region_handle = to_region_handle(pos_global);

+    LLVector3 pos_local = (LLVector3)(pos_global - from_region_handle(region_handle));

+    teleportRequest(region_handle, pos_local, getTeleportKeepsLookAt());

+}

+

+LLAgent::ETeleportState LLAgent::getTeleportState() const

+{

+    return (mTeleportRequest && (mTeleportRequest->getStatus() == LLTeleportRequest::kFailed)) ?

+        TELEPORT_NONE : mTeleportState;

+}

+

+

+void LLAgent::setTeleportState(ETeleportState state)

+{

+    if (mTeleportRequest && (state != TELEPORT_NONE) && (mTeleportRequest->getStatus() == LLTeleportRequest::kFailed))

+    {   // A late message has come in regarding a failed teleport.

+        // We have already decided that it failed so should not reinitiate the teleport sequence in the viewer.

+        LL_WARNS("Teleport") << "Attempt to set teleport state to " << state <<

+            " for previously failed teleport.  Ignore!" << LL_ENDL;

+        return;

+    }

+    LL_DEBUGS("Teleport") << "Setting teleport state to "

+                          << LLAgent::teleportStateName(state) << "(" << state << ")"

+                          << " Previous state: "

+                          << teleportStateName(mTeleportState) << "(" << mTeleportState << ")"

+                          << LL_ENDL;

+    mTeleportState = state;

+    if (mTeleportState > TELEPORT_NONE && gSavedSettings.getBOOL("FreezeTime"))

+    {

+        LLFloaterReg::hideInstance("snapshot");

+    }

+

+    switch (mTeleportState)

+    {

+        case TELEPORT_NONE:

+            mbTeleportKeepsLookAt = false;

+            break;

+

+        case TELEPORT_MOVING:

+        // We're outa here. Save "back" slurl.

+        LLAgentUI::buildSLURL(*mTeleportSourceSLURL);

+            break;

+

+        case TELEPORT_ARRIVING:

+        // First two position updates after a teleport tend to be weird

+        //LLViewerStats::getInstance()->mAgentPositionSnaps.mCountOfNextUpdatesToIgnore = 2;

+

+        // Let the interested parties know we've teleported.

+        LLViewerParcelMgr::getInstance()->onTeleportFinished(false, getPositionGlobal());

+            break;

+

+        default:

+            break;

+    }

+}

+

+

+void LLAgent::stopCurrentAnimations()

+{

+    LL_DEBUGS("Avatar") << "Stopping current animations" << LL_ENDL;

+

+    // This function stops all current overriding animations on this

+    // avatar, propagating this change back to the server.

+    if (isAgentAvatarValid())

+    {

+        std::vector<LLUUID> anim_ids;

+

+        for ( LLVOAvatar::AnimIterator anim_it =

+                  gAgentAvatarp->mPlayingAnimations.begin();

+              anim_it != gAgentAvatarp->mPlayingAnimations.end();

+              anim_it++)

+        {

+            if ((anim_it->first == ANIM_AGENT_DO_NOT_DISTURB)||

+                (anim_it->first == ANIM_AGENT_SIT_GROUND_CONSTRAINED))

+            {

+                // don't cancel a ground-sit anim, as viewers

+                // use this animation's status in

+                // determining whether we're sitting. ick.

+                LL_DEBUGS("Avatar") << "sit or do-not-disturb animation will not be stopped" << LL_ENDL;

+            }

+            else

+            {

+                // stop this animation locally

+                gAgentAvatarp->stopMotion(anim_it->first, true);

+                // ...and tell the server to tell everyone.

+                anim_ids.push_back(anim_it->first);

+            }

+        }

+

+        sendAnimationRequests(anim_ids, ANIM_REQUEST_STOP);

+

+        // Tell the region to clear any animation state overrides

+        sendAnimationStateReset();

+

+        // Revoke all animation permissions

+        if (mRegionp &&

+            gSavedSettings.getBOOL("RevokePermsOnStopAnimation"))

+        {

+            U32 permissions = SCRIPT_PERMISSIONS[SCRIPT_PERMISSION_TRIGGER_ANIMATION].permbit | SCRIPT_PERMISSIONS[SCRIPT_PERMISSION_OVERRIDE_ANIMATIONS].permbit;

+            sendRevokePermissions(mRegionp->getRegionID(), permissions);

+            if (gAgentAvatarp->isSitting())

+            {   // Also stand up, since auto-granted sit animation permission has been revoked

+                gAgent.standUp();

+            }

+        }

+

+        // re-assert at least the default standing animation, because

+        // viewers get confused by avs with no associated anims.

+        sendAnimationRequest(ANIM_AGENT_STAND, ANIM_REQUEST_START);

+    }

+}

+

+void LLAgent::fidget()

+{

+    if (!getAFK())

+    {

+        F32 curTime = mFidgetTimer.getElapsedTimeF32();

+        if (curTime > mNextFidgetTime)

+        {

+            // pick a random fidget anim here

+            S32 oldFidget = mCurrentFidget;

+

+            mCurrentFidget = ll_rand(NUM_AGENT_STAND_ANIMS);

+

+            if (mCurrentFidget != oldFidget)

+            {

+                LLAgent::stopFidget();

+

+

+                switch(mCurrentFidget)

+                {

+                case 0:

+                    mCurrentFidget = 0;

+                    break;

+                case 1:

+                    sendAnimationRequest(ANIM_AGENT_STAND_1, ANIM_REQUEST_START);

+                    mCurrentFidget = 1;

+                    break;

+                case 2:

+                    sendAnimationRequest(ANIM_AGENT_STAND_2, ANIM_REQUEST_START);

+                    mCurrentFidget = 2;

+                    break;

+                case 3:

+                    sendAnimationRequest(ANIM_AGENT_STAND_3, ANIM_REQUEST_START);

+                    mCurrentFidget = 3;

+                    break;

+                case 4:

+                    sendAnimationRequest(ANIM_AGENT_STAND_4, ANIM_REQUEST_START);

+                    mCurrentFidget = 4;

+                    break;

+                }

+            }

+

+            // calculate next fidget time

+            mNextFidgetTime = curTime + ll_frand(MAX_FIDGET_TIME - MIN_FIDGET_TIME) + MIN_FIDGET_TIME;

+        }

+    }

+}

+

+void LLAgent::stopFidget()

+{

+    std::vector<LLUUID> anims;

+    anims.reserve(4);

+    anims.push_back(ANIM_AGENT_STAND_1);

+    anims.push_back(ANIM_AGENT_STAND_2);

+    anims.push_back(ANIM_AGENT_STAND_3);

+    anims.push_back(ANIM_AGENT_STAND_4);

+

+    gAgent.sendAnimationRequests(anims, ANIM_REQUEST_STOP);

+}

+

+

+void LLAgent::requestEnterGodMode()

+{

+    LLMessageSystem* msg = gMessageSystem;

+    msg->newMessageFast(_PREHASH_RequestGodlikePowers);

+    msg->nextBlockFast(_PREHASH_AgentData);

+    msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());

+    msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());

+    msg->nextBlockFast(_PREHASH_RequestBlock);

+    msg->addBOOLFast(_PREHASH_Godlike, true);

+    msg->addUUIDFast(_PREHASH_Token, LLUUID::null);

+

+    // simulators need to know about your request

+    sendReliableMessage();

+}

+

+void LLAgent::requestLeaveGodMode()

+{

+    LLMessageSystem* msg = gMessageSystem;

+    msg->newMessageFast(_PREHASH_RequestGodlikePowers);

+    msg->nextBlockFast(_PREHASH_AgentData);

+    msg->addUUIDFast(_PREHASH_AgentID, gAgent.getID());

+    msg->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());

+    msg->nextBlockFast(_PREHASH_RequestBlock);

+    msg->addBOOLFast(_PREHASH_Godlike, false);

+    msg->addUUIDFast(_PREHASH_Token, LLUUID::null);

+

+    // simulator needs to know about your request

+    sendReliableMessage();

+}

+

+void LLAgent::sendAgentDataUpdateRequest()

+{

+    gMessageSystem->newMessageFast(_PREHASH_AgentDataUpdateRequest);

+    gMessageSystem->nextBlockFast(_PREHASH_AgentData);

+    gMessageSystem->addUUIDFast(_PREHASH_AgentID, gAgent.getID() );

+    gMessageSystem->addUUIDFast(_PREHASH_SessionID, gAgent.getSessionID());

+    sendReliableMessage();

+}

+

+void LLAgent::sendAgentUserInfoRequest()

+{

+    std::string cap;

+

+    if (getID().isNull())

+        return; // not logged in

+

+    if (mRegionp)

+        cap = mRegionp->getCapability("UserInfo");

+

+    if (!cap.empty())

+    {

+        LLCoros::instance().launch("requestAgentUserInfoCoro",

+            boost::bind(&LLAgent::requestAgentUserInfoCoro, this, cap));

+    }

+    else

+    {

+        sendAgentUserInfoRequestMessage();

+    }

+}

+

+void LLAgent::requestAgentUserInfoCoro(std::string capurl)

+{

+    LLCore::HttpRequest::policy_t httpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID);

+    LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t

+        httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("requestAgentUserInfoCoro", httpPolicy));

+    LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);

+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);

+    LLCore::HttpHeaders::ptr_t httpHeaders;

+

+    httpOpts->setFollowRedirects(true);

+

+    LLSD result = httpAdapter->getAndSuspend(httpRequest, capurl, httpOpts, httpHeaders);

+

+    LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];

+    LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);

+

+    if (!status)

+    {

+        LL_WARNS("UserInfo") << "Failed to get user information." << LL_ENDL;

+        return;

+    }

+    else if (!result["success"].asBoolean())

+    {

+        LL_WARNS("UserInfo") << "Failed to get user information: " << result["message"] << LL_ENDL;

+        return;

+    }

+

+    std::string email;

+    std::string dir_visibility;

+

+    email = result["email"].asString();

+    dir_visibility = result["directory_visibility"].asString();

+

+    // TODO: This should probably be changed.  I'm not entirely comfortable

+    // having LLAgent interact directly with the UI in this way.

+    LLFloaterPreference::updateUserInfo(dir_visibility);

+    LLFloaterSnapshot::setAgentEmail(email);

+}

+

+void LLAgent::sendAgentUpdateUserInfo(const std::string& directory_visibility)

+{

+    std::string cap;

+

+    if (getID().isNull())

+        return; // not logged in

+

+    if (mRegionp)

+        cap = mRegionp->getCapability("UserInfo");

+

+    if (!cap.empty())

+    {

+        LLCoros::instance().launch("updateAgentUserInfoCoro",

+            boost::bind(&LLAgent::updateAgentUserInfoCoro, this, cap, directory_visibility));

+    }

+    else

+    {

+        sendAgentUpdateUserInfoMessage(directory_visibility);

+    }

+}

+

+

+void LLAgent::updateAgentUserInfoCoro(std::string capurl, std::string directory_visibility)

+{

+    LLCore::HttpRequest::policy_t httpPolicy(LLCore::HttpRequest::DEFAULT_POLICY_ID);

+    LLCoreHttpUtil::HttpCoroutineAdapter::ptr_t

+        httpAdapter(new LLCoreHttpUtil::HttpCoroutineAdapter("requestAgentUserInfoCoro", httpPolicy));

+    LLCore::HttpRequest::ptr_t httpRequest(new LLCore::HttpRequest);

+    LLCore::HttpOptions::ptr_t httpOpts(new LLCore::HttpOptions);

+    LLCore::HttpHeaders::ptr_t httpHeaders;

+

+    httpOpts->setFollowRedirects(true);

+    LLSD body(LLSDMap

+        ("dir_visibility",  LLSD::String(directory_visibility)));

+

+

+    LLSD result = httpAdapter->postAndSuspend(httpRequest, capurl, body, httpOpts, httpHeaders);

+

+    LLSD httpResults = result[LLCoreHttpUtil::HttpCoroutineAdapter::HTTP_RESULTS];

+    LLCore::HttpStatus status = LLCoreHttpUtil::HttpCoroutineAdapter::getStatusFromLLSD(httpResults);

+

+    if (!status)

+    {

+        LL_WARNS("UserInfo") << "Failed to set user information." << LL_ENDL;

+    }

+    else if (!result["success"].asBoolean())

+    {

+        LL_WARNS("UserInfo") << "Failed to set user information: " << result["message"] << LL_ENDL;

+    }

+}

+

+// deprecated:

+// May be removed when UserInfo cap propagates to all simhosts in grid

+void LLAgent::sendAgentUserInfoRequestMessage()

+{

+    gMessageSystem->newMessageFast(_PREHASH_UserInfoRequest);

+    gMessageSystem->nextBlockFast(_PREHASH_AgentData);

+    gMessageSystem->addUUIDFast(_PREHASH_AgentID, getID());

+    gMessageSystem->addUUIDFast(_PREHASH_SessionID, getSessionID());

+    sendReliableMessage();

+}

+

+void LLAgent::sendAgentUpdateUserInfoMessage(const std::string& directory_visibility)

+{

+    gMessageSystem->newMessageFast(_PREHASH_UpdateUserInfo);

+    gMessageSystem->nextBlockFast(_PREHASH_AgentData);

+    gMessageSystem->addUUIDFast(_PREHASH_AgentID, getID());

+    gMessageSystem->addUUIDFast(_PREHASH_SessionID, getSessionID());

+    gMessageSystem->nextBlockFast(_PREHASH_UserData);

+    gMessageSystem->addString("DirectoryVisibility", directory_visibility);

+    gAgent.sendReliableMessage();

+

+}

+// end deprecated

+//------

+

+void LLAgent::observeFriends()

+{

+    if(!mFriendObserver)

+    {

+        mFriendObserver = new LLAgentFriendObserver;

+        LLAvatarTracker::instance().addObserver(mFriendObserver);

+        friendsChanged();

+    }

+}

+

+std::map<S32, std::string> LLAgent::sTeleportStateName = { { TELEPORT_NONE, "TELEPORT_NONE" },

+                                                           { TELEPORT_START, "TELEPORT_START" },

+                                                           { TELEPORT_REQUESTED, "TELEPORT_REQUESTED" },

+                                                           { TELEPORT_MOVING, "TELEPORT_MOVING" },

+                                                           { TELEPORT_START_ARRIVAL, "TELEPORT_START_ARRIVAL" },

+                                                           { TELEPORT_ARRIVING, "TELEPORT_ARRIVING" },

+                                                           { TELEPORT_LOCAL, "TELEPORT_LOCAL" },

+                                                           { TELEPORT_PENDING, "TELEPORT_PENDING" } };

+

+const std::string& LLAgent::teleportStateName(S32 state)

+{

+    static std::string invalid_state_str("INVALID");

+    auto iter = LLAgent::sTeleportStateName.find(state);

+    if (iter != LLAgent::sTeleportStateName.end())

+    {

+        return iter->second;

+    }

+    else

+    {

+        return invalid_state_str;

+    }

+}

+

+const std::string& LLAgent::getTeleportStateName() const

+{

+    return teleportStateName(getTeleportState());

+}

+

+void LLAgent::parseTeleportMessages(const std::string& xml_filename)

+{

+    LLXMLNodePtr root;

+    bool success = LLUICtrlFactory::getLayeredXMLNode(xml_filename, root);

+

+    if (!success || !root || !root->hasName( "teleport_messages" ))

+    {

+        LL_ERRS() << "Problem reading teleport string XML file: "

+               << xml_filename << LL_ENDL;

+        return;

+    }

+

+    for (LLXMLNode* message_set = root->getFirstChild();

+         message_set != NULL;

+         message_set = message_set->getNextSibling())

+    {

+        if ( !message_set->hasName("message_set") ) continue;

+

+        std::map<std::string, std::string> *teleport_msg_map = NULL;

+        std::string message_set_name;

+

+        if ( message_set->getAttributeString("name", message_set_name) )

+        {

+            //now we loop over all the string in the set and add them

+            //to the appropriate set

+            if ( message_set_name == "errors" )

+            {

+                teleport_msg_map = &sTeleportErrorMessages;

+            }

+            else if ( message_set_name == "progress" )

+            {

+                teleport_msg_map = &sTeleportProgressMessages;

+            }

+        }

+

+        if ( !teleport_msg_map ) continue;

+

+        std::string message_name;

+        for (LLXMLNode* message_node = message_set->getFirstChild();

+             message_node != NULL;

+             message_node = message_node->getNextSibling())

+        {

+            if ( message_node->hasName("message") &&

+                 message_node->getAttributeString("name", message_name) )

+            {

+                (*teleport_msg_map)[message_name] =

+                    message_node->getTextContents();

+            } //end if ( message exists and has a name)

+        } //end for (all message in set)

+    }//end for (all message sets in xml file)

+}

+

+const void LLAgent::getTeleportSourceSLURL(LLSLURL& slurl) const

+{

+    slurl = *mTeleportSourceSLURL;

+}

+

+// static

+void LLAgent::dumpGroupInfo()

+{

+    LL_INFOS() << "group   " << gAgent.mGroupName << LL_ENDL;

+    LL_INFOS() << "ID      " << gAgent.mGroupID << LL_ENDL;

+    LL_INFOS() << "powers " << gAgent.mGroupPowers << LL_ENDL;

+    LL_INFOS() << "title   " << gAgent.mGroupTitle << LL_ENDL;

+    //LL_INFOS() << "insig   " << gAgent.mGroupInsigniaID << LL_ENDL;

+}

+

+// Draw a representation of current autopilot target

+void LLAgent::renderAutoPilotTarget()

+{

+    if (mAutoPilot)

+    {

+        F32 height_meters;

+        LLVector3d target_global;

+

+        gGL.matrixMode(LLRender::MM_MODELVIEW);

+        gGL.pushMatrix();

+

+        // not textured

+        gGL.getTexUnit(0)->unbind(LLTexUnit::TT_TEXTURE);

+

+        // lovely green

+        gGL.color4f(0.f, 1.f, 1.f, 1.f);

+

+        target_global = mAutoPilotTargetGlobal;

+

+        gGL.translatef((F32)(target_global.mdV[VX]), (F32)(target_global.mdV[VY]), (F32)(target_global.mdV[VZ]));

+

+        height_meters = 1.f;

+

+        gGL.scalef(height_meters, height_meters, height_meters);

+

+        gSphere.render();

+

+        gGL.popMatrix();

+    }

+}

+

+/********************************************************************************/

+

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

+// LLTeleportRequest

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

+

+LLTeleportRequest::LLTeleportRequest()

+    : mStatus(kPending)

+{

+}

+

+LLTeleportRequest::~LLTeleportRequest()

+{

+}

+

+bool LLTeleportRequest::canRestartTeleport()

+{

+    return false;

+}

+

+void LLTeleportRequest::restartTeleport()

+{

+    llassert(0);

+}

+

+// TODO this enum -> name idiom should be in a common class rather than repeated various places.

+const std::string& LLTeleportRequest::statusName(EStatus status)

+{

+    static std::string invalid_status_str("INVALID");

+    auto iter = LLTeleportRequest::sTeleportStatusName.find(status);

+    if (iter != LLTeleportRequest::sTeleportStatusName.end())

+    {

+        return iter->second;

+    }

+    else

+    {

+        return invalid_status_str;

+    }

+}

+

+std::ostream& operator<<(std::ostream& os, const LLTeleportRequest& req)

+{

+    req.toOstream(os);

+    return os;

+}

+

+void LLTeleportRequest::toOstream(std::ostream& os) const

+{

+    os << "status " << statusName(mStatus) << "(" << mStatus << ")";

+}

+

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

+// LLTeleportRequestViaLandmark

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

+LLTeleportRequestViaLandmark::LLTeleportRequestViaLandmark(const LLUUID &pLandmarkId)

+    : LLTeleportRequest(),

+    mLandmarkId(pLandmarkId)

+{

+    LL_INFOS("Teleport") << "LLTeleportRequestViaLandmark created, " << *this << LL_ENDL;

+}

+

+LLTeleportRequestViaLandmark::~LLTeleportRequestViaLandmark()

+{

+    LL_INFOS("Teleport") << "~LLTeleportRequestViaLandmark, " << *this << LL_ENDL;

+}

+

+void LLTeleportRequestViaLandmark::toOstream(std::ostream& os) const

+{

+    os << "landmark " << mLandmarkId << " ";

+    LLTeleportRequest::toOstream(os);

+}

+

+bool LLTeleportRequestViaLandmark::canRestartTeleport()

+{

+    LL_INFOS("Teleport") << "LLTeleportRequestViaLandmark::canRestartTeleport? -> true, " << *this << LL_ENDL;

+    return true;

+}

+

+void LLTeleportRequestViaLandmark::startTeleport()

+{

+    LL_INFOS("Teleport") << "LLTeleportRequestViaLandmark::startTeleport, " << *this << LL_ENDL;

+    gAgent.doTeleportViaLandmark(getLandmarkId());

+}

+

+void LLTeleportRequestViaLandmark::restartTeleport()

+{

+    LL_INFOS("Teleport") << "LLTeleportRequestViaLandmark::restartTeleport, " << *this << LL_ENDL;

+    gAgent.doTeleportViaLandmark(getLandmarkId());

+}

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

+// LLTeleportRequestViaLure

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

+

+LLTeleportRequestViaLure::LLTeleportRequestViaLure(const LLUUID &pLureId, bool pIsLureGodLike)

+    : LLTeleportRequestViaLandmark(pLureId),

+    mIsLureGodLike(pIsLureGodLike)

+{

+    LL_INFOS("Teleport") << "LLTeleportRequestViaLure created" << LL_ENDL;

+}

+

+LLTeleportRequestViaLure::~LLTeleportRequestViaLure()

+{

+    LL_INFOS("Teleport") << "~LLTeleportRequestViaLure" << LL_ENDL;

+}

+

+void LLTeleportRequestViaLure::toOstream(std::ostream& os) const

+{

+    os << "mIsLureGodLike " << (S32) mIsLureGodLike << " ";

+    LLTeleportRequestViaLandmark::toOstream(os);

+}

+

+bool LLTeleportRequestViaLure::canRestartTeleport()

+{

+    // stinson 05/17/2012 : cannot restart a teleport via lure because of server-side restrictions

+    // The current scenario is as follows:

+    //    1. User A initializes a request for User B to teleport via lure

+    //    2. User B accepts the teleport via lure request

+    //    3. The server sees the init request from User A and the accept request from User B and matches them up

+    //    4. The server then removes the paired requests up from the "queue"

+    //    5. The server then fails User B's teleport for reason of maturity level (for example)

+    //    6. User B's viewer prompts user to increase their maturity level profile value.

+    //    7. User B confirms and accepts increase in maturity level

+    //    8. User B's viewer then attempts to teleport via lure again

+    //    9. This request will time-out on the viewer-side because User A's initial request has been removed from the "queue" in step 4

+

+    LL_INFOS("Teleport") << "LLTeleportRequestViaLure::canRestartTeleport? -> false" << LL_ENDL;

+    return false;

+}

+

+void LLTeleportRequestViaLure::startTeleport()

+{

+    LL_INFOS("Teleport") << "LLTeleportRequestViaLure::startTeleport" << LL_ENDL;

+    gAgent.doTeleportViaLure(getLandmarkId(), isLureGodLike());

+}

+

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

+// LLTeleportRequestViaLocation

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

+

+LLTeleportRequestViaLocation::LLTeleportRequestViaLocation(const LLVector3d &pPosGlobal)

+    : LLTeleportRequest(),

+    mPosGlobal(pPosGlobal)

+{

+    LL_INFOS("Teleport") << "LLTeleportRequestViaLocation created" << LL_ENDL;

+}

+

+LLTeleportRequestViaLocation::~LLTeleportRequestViaLocation()

+{

+    LL_INFOS("Teleport") << "~LLTeleportRequestViaLocation" << LL_ENDL;

+}

+

+void LLTeleportRequestViaLocation::toOstream(std::ostream& os) const

+{

+    os << "mPosGlobal " << mPosGlobal << " ";

+    LLTeleportRequest::toOstream(os);

+}

+

+bool LLTeleportRequestViaLocation::canRestartTeleport()

+{

+    LL_INFOS("Teleport") << "LLTeleportRequestViaLocation::canRestartTeleport -> true" << LL_ENDL;

+    return true;

+}

+

+void LLTeleportRequestViaLocation::startTeleport()

+{

+    LL_INFOS("Teleport") << "LLTeleportRequestViaLocation::startTeleport" << LL_ENDL;

+    gAgent.doTeleportViaLocation(getPosGlobal());

+}

+

+void LLTeleportRequestViaLocation::restartTeleport()

+{

+    LL_INFOS("Teleport") << "LLTeleportRequestViaLocation::restartTeleport" << LL_ENDL;

+    gAgent.doTeleportViaLocation(getPosGlobal());

+}

+

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

+// LLTeleportRequestViaLocationLookAt

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

+

+LLTeleportRequestViaLocationLookAt::LLTeleportRequestViaLocationLookAt(const LLVector3d &pPosGlobal)

+    : LLTeleportRequestViaLocation(pPosGlobal)

+{

+    LL_INFOS("Teleport") << "LLTeleportRequestViaLocationLookAt created" << LL_ENDL;

+}

+

+LLTeleportRequestViaLocationLookAt::~LLTeleportRequestViaLocationLookAt()

+{

+    LL_INFOS("Teleport") << "~LLTeleportRequestViaLocationLookAt" << LL_ENDL;

+}

+

+void LLTeleportRequestViaLocationLookAt::toOstream(std::ostream& os) const

+{

+    LLTeleportRequestViaLocation::toOstream(os);

+}

+

+bool LLTeleportRequestViaLocationLookAt::canRestartTeleport()

+{

+    LL_INFOS("Teleport") << "LLTeleportRequestViaLocationLookAt::canRestartTeleport -> true" << LL_ENDL;

+    return true;

+}

+

+void LLTeleportRequestViaLocationLookAt::startTeleport()

+{

+    LL_INFOS("Teleport") << "LLTeleportRequestViaLocationLookAt::startTeleport" << LL_ENDL;

+    gAgent.doTeleportViaLocationLookAt(getPosGlobal());

+}

+

+void LLTeleportRequestViaLocationLookAt::restartTeleport()

+{

+    LL_INFOS("Teleport") << "LLTeleportRequestViaLocationLookAt::restartTeleport" << LL_ENDL;

+    gAgent.doTeleportViaLocationLookAt(getPosGlobal());

+}

+

+// EOF