1 files changed, 383 insertions, 104 deletions

diff --git a/indra/newview/lltoolpie.cpp b/indra/newview/lltoolpie.cpp
index d992d808c7..9ec4d33036 100644
--- a/indra/newview/lltoolpie.cpp
+++ b/indra/newview/lltoolpie.cpp
@@ -37,7 +37,7 @@
 #include "llavatarnamecache.h"
 #include "llviewercontrol.h"
 #include "llfocusmgr.h"
-//#include "llfirstuse.h"
+#include "llfirstuse.h"
 #include "llfloaterland.h"
 #include "llfloaterreg.h"
 #include "llfloaterscriptdebug.h"
@@ -79,11 +79,16 @@ static ECursorType cursor_from_parcel_media(U8 click_action);
 
 LLToolPie::LLToolPie()
 :	LLTool(std::string("Pie")),
-	mGrabMouseButtonDown( FALSE ),
-	mMouseOutsideSlop( FALSE ),
-	mClickAction(0)
-{ }
-
+	mMouseButtonDown( false ),
+	mMouseOutsideSlop( false ),
+	mMouseSteerX(-1),
+	mMouseSteerY(-1),
+	mBlockClickToWalk(false),
+	mClickAction(0),
+	mClickActionBuyEnabled( gSavedSettings.getBOOL("ClickActionBuyEnabled") ),
+	mClickActionPayEnabled( gSavedSettings.getBOOL("ClickActionPayEnabled") )
+{
+}
 
 BOOL LLToolPie::handleAnyMouseClick(S32 x, S32 y, MASK mask, EClickType clicktype, BOOL down)
 {
@@ -97,12 +102,17 @@ BOOL LLToolPie::handleAnyMouseClick(S32 x, S32 y, MASK mask, EClickType clicktyp
 
 BOOL LLToolPie::handleMouseDown(S32 x, S32 y, MASK mask)
 {
+	mMouseOutsideSlop = FALSE;
+	mMouseDownX = x;
+	mMouseDownY = y;
+
 	//left mouse down always picks transparent
 	mPick = gViewerWindow->pickImmediate(x, y, TRUE);
 	mPick.mKeyMask = mask;
-	mGrabMouseButtonDown = TRUE;
+
+	mMouseButtonDown = true;
 	
-	pickLeftMouseDownCallback();
+	handleLeftClickPick();
 
 	return TRUE;
 }
@@ -117,7 +127,7 @@ BOOL LLToolPie::handleRightMouseDown(S32 x, S32 y, MASK mask)
 
 	// claim not handled so UI focus stays same
 	
-	pickRightMouseDownCallback();
+	handleRightClickPick();
 	
 	return FALSE;
 }
@@ -134,7 +144,7 @@ BOOL LLToolPie::handleScrollWheel(S32 x, S32 y, S32 clicks)
 }
 
 // True if you selected an object.
-BOOL LLToolPie::pickLeftMouseDownCallback()
+BOOL LLToolPie::handleLeftClickPick()
 {
 	S32 x = mPick.mMousePt.mX;
 	S32 y = mPick.mMousePt.mY;
@@ -211,12 +221,28 @@ BOOL LLToolPie::pickLeftMouseDownCallback()
 				} // else nothing (fall through to touch)
 			}
 		case CLICK_ACTION_PAY:
-			if ((object && object->flagTakesMoney())
-				|| (parent && parent->flagTakesMoney()))
+			if ( mClickActionPayEnabled )
+			{
+				if ((object && object->flagTakesMoney())
+					|| (parent && parent->flagTakesMoney()))
+				{
+					// pay event goes to object actually clicked on
+					mClickActionObject = object;
+					mLeftClickSelection = LLToolSelect::handleObjectSelection(mPick, FALSE, TRUE);
+					if (LLSelectMgr::getInstance()->selectGetAllValid())
+					{
+						// call this right away, since we have all the info we need to continue the action
+						selectionPropertiesReceived();
+					}
+					return TRUE;
+				}
+			}
+			break;
+		case CLICK_ACTION_BUY:
+			if ( mClickActionBuyEnabled )
 			{
-				// pay event goes to object actually clicked on
-				mClickActionObject = object;
-				mLeftClickSelection = LLToolSelect::handleObjectSelection(mPick, FALSE, TRUE);
+				mClickActionObject = parent;
+				mLeftClickSelection = LLToolSelect::handleObjectSelection(mPick, FALSE, TRUE, TRUE);
 				if (LLSelectMgr::getInstance()->selectGetAllValid())
 				{
 					// call this right away, since we have all the info we need to continue the action
@@ -225,15 +251,6 @@ BOOL LLToolPie::pickLeftMouseDownCallback()
 				return TRUE;
 			}
 			break;
-		case CLICK_ACTION_BUY:
-			mClickActionObject = parent;
-			mLeftClickSelection = LLToolSelect::handleObjectSelection(mPick, FALSE, TRUE, TRUE);
-			if (LLSelectMgr::getInstance()->selectGetAllValid())
-			{
-				// call this right away, since we have all the info we need to continue the action
-				selectionPropertiesReceived();
-			}
-			return TRUE;
 		case CLICK_ACTION_OPEN:
 			if (parent && parent->allowOpen())
 			{
@@ -283,7 +300,12 @@ BOOL LLToolPie::pickLeftMouseDownCallback()
 	}
 
 	// put focus back "in world"
-	gFocusMgr.setKeyboardFocus(NULL);
+	if (gFocusMgr.getKeyboardFocus())
+	{
+		// don't click to walk on attempt to give focus to world
+		mBlockClickToWalk = true;
+		gFocusMgr.setKeyboardFocus(NULL);
+	}
 
 	BOOL touchable = (object && object->flagHandleTouch()) 
 					 || (parent && parent->flagHandleTouch());
@@ -295,6 +317,7 @@ BOOL LLToolPie::pickLeftMouseDownCallback()
 		)
 	{
 		gGrabTransientTool = this;
+		mMouseButtonDown = false;
 		LLToolMgr::getInstance()->getCurrentToolset()->selectTool( LLToolGrab::getInstance() );
 		return LLToolGrab::getInstance()->handleObjectHit( mPick );
 	}
@@ -310,9 +333,9 @@ BOOL LLToolPie::pickLeftMouseDownCallback()
 	if (!gSavedSettings.getBOOL("LeftClickShowMenu"))
 	{
 		// mouse already released
-		if (!mGrabMouseButtonDown)
+		if (!mMouseButtonDown)
 		{
-			return TRUE;
+			return true;
 		}
 
 		while( object && object->isAttachment() && !object->flagHandleTouch())
@@ -324,9 +347,10 @@ BOOL LLToolPie::pickLeftMouseDownCallback()
 			}
 			object = (LLViewerObject*)object->getParent();
 		}
-		if (object && object == gAgentAvatarp)
+		if (object && object == gAgentAvatarp && !gSavedSettings.getBOOL("ClickToWalk"))
 		{
 			// we left clicked on avatar, switch to focus mode
+			mMouseButtonDown = false;
 			LLToolMgr::getInstance()->setTransientTool(LLToolCamera::getInstance());
 			gViewerWindow->hideCursor();
 			LLToolCamera::getInstance()->setMouseCapture(TRUE);
@@ -393,7 +417,7 @@ U8 final_click_action(LLViewerObject* obj)
 	return click_action;
 }
 
-ECursorType cursor_from_object(LLViewerObject* object)
+ECursorType LLToolPie::cursorFromObject(LLViewerObject* object)
 {
 	LLViewerObject* parent = NULL;
 	if (object)
@@ -413,7 +437,10 @@ ECursorType cursor_from_object(LLViewerObject* object)
 		}
 		break;
 	case CLICK_ACTION_BUY:
-		cursor = UI_CURSOR_TOOLBUY;
+		if ( mClickActionBuyEnabled )
+		{
+			cursor = UI_CURSOR_TOOLBUY;
+		}
 		break;
 	case CLICK_ACTION_OPEN:
 		// Open always opens the parent.
@@ -423,10 +450,13 @@ ECursorType cursor_from_object(LLViewerObject* object)
 		}
 		break;
 	case CLICK_ACTION_PAY:	
-		if ((object && object->flagTakesMoney())
-			|| (parent && parent->flagTakesMoney()))
+		if ( mClickActionPayEnabled )
 		{
-			cursor = UI_CURSOR_TOOLBUY;
+			if ((object && object->flagTakesMoney())
+				|| (parent && parent->flagTakesMoney()))
+			{
+				cursor = UI_CURSOR_TOOLBUY;
+			}
 		}
 		break;
 	case CLICK_ACTION_ZOOM:
@@ -474,10 +504,16 @@ void LLToolPie::selectionPropertiesReceived()
 			switch (click_action)
 			{
 			case CLICK_ACTION_BUY:
-				handle_buy();
+				if ( LLToolPie::getInstance()->mClickActionBuyEnabled )
+				{
+					handle_buy();
+				}
 				break;
 			case CLICK_ACTION_PAY:
-				handle_give_money_dialog();
+				if ( LLToolPie::getInstance()->mClickActionPayEnabled )
+				{
+					handle_give_money_dialog();
+				}
 				break;
 			case CLICK_ACTION_OPEN:
 				LLFloaterReg::showInstance("openobject");
@@ -493,20 +529,16 @@ void LLToolPie::selectionPropertiesReceived()
 BOOL LLToolPie::handleHover(S32 x, S32 y, MASK mask)
 {
 	mHoverPick = gViewerWindow->pickImmediate(x, y, FALSE);
-	// perform a separate pick that detects transparent objects since they respond to 1-click actions
-	LLPickInfo click_action_pick = gViewerWindow->pickImmediate(x, y, TRUE);
-
-	// Show screen-space highlight glow effect
-	bool show_highlight = false;
 	LLViewerObject *parent = NULL;
 	LLViewerObject *object = mHoverPick.getObject();
-
 	if (object)
 	{
 		parent = object->getRootEdit();
 	}
 
-	LLViewerObject* click_action_object = click_action_pick.getObject();
+	// Show screen-space highlight glow effect
+	bool show_highlight = false;
+
 	if (handleMediaHover(mHoverPick))
 	{
 		// *NOTE: If you think the hover glow conflicts with the media outline, you
@@ -515,39 +547,70 @@ BOOL LLToolPie::handleHover(S32 x, S32 y, MASK mask)
 		// cursor set by media object
 		lldebugst(LLERR_USER_INPUT) << "hover handled by LLToolPie (inactive)" << llendl;
 	}
-	else if (click_action_object && useClickAction(mask, click_action_object, click_action_object->getRootEdit()))
+	else if (!mMouseOutsideSlop 
+		&& mMouseButtonDown 
+		&& gSavedSettings.getBOOL("ClickToWalk"))
 	{
-		show_highlight = true;
-		ECursorType cursor = cursor_from_object(click_action_object);
-		gViewerWindow->setCursor(cursor);
-		lldebugst(LLERR_USER_INPUT) << "hover handled by LLToolPie (inactive)" << llendl;
+		S32 delta_x = x - mMouseDownX;
+		S32 delta_y = y - mMouseDownY;
+		S32 threshold = gSavedSettings.getS32("DragAndDropDistanceThreshold");
+		if (delta_x * delta_x + delta_y * delta_y > threshold * threshold)
+		{
+			startCameraSteering();
+			steerCameraWithMouse(x, y);
+			gViewerWindow->setCursor(UI_CURSOR_TOOLGRAB);
+		}
+		else
+		{
+			gViewerWindow->setCursor(UI_CURSOR_ARROW);
+		}
 	}
-	
-	else if ((object && !object->isAvatar() && object->usePhysics()) 
-			 || (parent && !parent->isAvatar() && parent->usePhysics()))
+	else if (inCameraSteerMode())
 	{
-		show_highlight = true;
+		steerCameraWithMouse(x, y);
 		gViewerWindow->setCursor(UI_CURSOR_TOOLGRAB);
-		lldebugst(LLERR_USER_INPUT) << "hover handled by LLToolPie (inactive)" << llendl;
-	}
-	else if ( (object && object->flagHandleTouch()) 
-			  || (parent && parent->flagHandleTouch()))
-	{
-		show_highlight = true;
-		gViewerWindow->setCursor(UI_CURSOR_HAND);
-		lldebugst(LLERR_USER_INPUT) << "hover handled by LLToolPie (inactive)" << llendl;
 	}
 	else
 	{
-		gViewerWindow->setCursor(UI_CURSOR_ARROW);
-		lldebugst(LLERR_USER_INPUT) << "hover handled by LLToolPie (inactive)" << llendl;
+		// perform a separate pick that detects transparent objects since they respond to 1-click actions
+		LLPickInfo click_action_pick = gViewerWindow->pickImmediate(x, y, TRUE);
+
+		LLViewerObject* click_action_object = click_action_pick.getObject();
 
-		if(!object)
+		if (click_action_object && useClickAction(mask, click_action_object, click_action_object->getRootEdit()))
+		{
+			show_highlight = true;
+			ECursorType cursor = cursorFromObject(click_action_object);
+			gViewerWindow->setCursor(cursor);
+			lldebugst(LLERR_USER_INPUT) << "hover handled by LLToolPie (inactive)" << llendl;
+		}
+		
+		else if ((object && !object->isAvatar() && object->usePhysics()) 
+				 || (parent && !parent->isAvatar() && parent->usePhysics()))
+		{
+			show_highlight = true;
+			gViewerWindow->setCursor(UI_CURSOR_TOOLGRAB);
+			lldebugst(LLERR_USER_INPUT) << "hover handled by LLToolPie (inactive)" << llendl;
+		}
+		else if ( (object && object->flagHandleTouch()) 
+				  || (parent && parent->flagHandleTouch()))
+		{
+			show_highlight = true;
+			gViewerWindow->setCursor(UI_CURSOR_HAND);
+			lldebugst(LLERR_USER_INPUT) << "hover handled by LLToolPie (inactive)" << llendl;
+		}
+		else
 		{
-			LLViewerMediaFocus::getInstance()->clearHover();
+			gViewerWindow->setCursor(UI_CURSOR_ARROW);
+			lldebugst(LLERR_USER_INPUT) << "hover handled by LLToolPie (inactive)" << llendl;
 		}
 	}
 
+	if(!object)
+	{
+		LLViewerMediaFocus::getInstance()->clearHover();
+	}
+
 	static LLCachedControl<bool> enable_highlight(
 		gSavedSettings, "RenderHoverGlowEnable", false);
 	LLDrawable* drawable = NULL;
@@ -563,40 +626,77 @@ BOOL LLToolPie::handleHover(S32 x, S32 y, MASK mask)
 BOOL LLToolPie::handleMouseUp(S32 x, S32 y, MASK mask)
 {
 	LLViewerObject* obj = mPick.getObject();
-
-	handleMediaMouseUp();
-
 	U8 click_action = final_click_action(obj);
-	if (click_action != CLICK_ACTION_NONE)
+
+	// let media have first pass at click
+	if (handleMediaMouseUp() || LLViewerMediaFocus::getInstance()->getFocus())
 	{
-		switch(click_action)
+		mBlockClickToWalk = true;
+	}
+	stopCameraSteering();
+	mMouseButtonDown = false;
+
+	if (click_action == CLICK_ACTION_NONE				// not doing 1-click action
+		&& gSavedSettings.getBOOL("ClickToWalk")		// click to walk enabled
+		&& !gAgent.getFlying()							// don't auto-navigate while flying until that works
+		&& !gAgentAvatarp->isSitting()
+		&& !mBlockClickToWalk							// another behavior hasn't cancelled click to walk
+		&& !mPick.mPosGlobal.isExactlyZero()			// valid coordinates for pick
+		&& (mPick.mPickType == LLPickInfo::PICK_LAND	// we clicked on land
+			|| mPick.mObjectID.notNull()))				// or on an object
+	{
+		// handle special cases of steering picks
+		LLViewerObject* avatar_object = mPick.getObject();
+
+		// get pointer to avatar
+		while (avatar_object && !avatar_object->isAvatar())
 		{
-		case CLICK_ACTION_BUY:
-		case CLICK_ACTION_PAY:
-		case CLICK_ACTION_OPEN:
-		case CLICK_ACTION_ZOOM:
-		case CLICK_ACTION_PLAY:
-		case CLICK_ACTION_OPEN_MEDIA:
-			// Because these actions open UI dialogs, we won't change
-			// the cursor again until the next hover and GL pick over
-			// the world.  Keep the cursor an arrow, assuming that 
-			// after the user moves off the UI, they won't be on the
-			// same object anymore.
-			gViewerWindow->setCursor(UI_CURSOR_ARROW);
-			// Make sure the hover-picked object is ignored.
-			//gToolTipView->resetLastHoverObject();
-			break;
-		default:
-			break;
+			avatar_object = (LLViewerObject*)avatar_object->getParent();
+		}
+
+		if (avatar_object && ((LLVOAvatar*)avatar_object)->isSelf())
+		{
+			const F64 SELF_CLICK_WALK_DISTANCE = 3.0;
+			// pretend we picked some point a bit in front of avatar
+			mPick.mPosGlobal = gAgent.getPositionGlobal() + LLVector3d(LLViewerCamera::instance().getAtAxis()) * SELF_CLICK_WALK_DISTANCE;
 		}
+		gAgentCamera.setFocusOnAvatar(TRUE, TRUE);
+		if(mAutoPilotDestination) { mAutoPilotDestination->markDead(); }
+		mAutoPilotDestination = (LLHUDEffectBlob *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_BLOB, FALSE);
+		mAutoPilotDestination->setPositionGlobal(mPick.mPosGlobal);
+		mAutoPilotDestination->setPixelSize(5);
+		mAutoPilotDestination->setColor(LLColor4U(170, 210, 190));
+		mAutoPilotDestination->setDuration(3.f);
+
+		handle_go_to();
+		LLFirstUse::notMoving(false);
+
+		mBlockClickToWalk = false;
+
+		return TRUE;
+	}
+	gViewerWindow->setCursor(UI_CURSOR_ARROW);
+	if (hasMouseCapture())
+	{
+		setMouseCapture(FALSE);
 	}
 
-	mGrabMouseButtonDown = FALSE;
 	LLToolMgr::getInstance()->clearTransientTool();
 	gAgentCamera.setLookAt(LOOKAT_TARGET_CONVERSATION, obj); // maybe look at object/person clicked on
+
+	mBlockClickToWalk = false;
 	return LLTool::handleMouseUp(x, y, mask);
 }
 
+void LLToolPie::stopClickToWalk()
+{
+	mPick.mPosGlobal = gAgent.getPositionGlobal();
+	handle_go_to();
+	if(mAutoPilotDestination) 
+	{ 
+		mAutoPilotDestination->markDead(); 
+	}
+}
 
 BOOL LLToolPie::handleDoubleClick(S32 x, S32 y, MASK mask)
 {
@@ -913,7 +1013,7 @@ BOOL LLToolPie::handleTooltipObject( LLViewerObject* hover_object, std::string l
 			p.click_callback(boost::bind(showAvatarInspector, hover_object->getID()));
 			p.visible_time_near(6.f);
 			p.visible_time_far(3.f);
-			p.delay_time(0.35f);
+			p.delay_time(gSavedSettings.getF32("AvatarInspectorTooltipDelay"));
 			p.wrap(false);
 			
 			LLToolTipMgr::instance().show(p);
@@ -1031,7 +1131,7 @@ BOOL LLToolPie::handleTooltipObject( LLViewerObject* hover_object, std::string l
 				p.click_homepage_callback(boost::bind(VisitHomePage, mHoverPick));
 				p.visible_time_near(6.f);
 				p.visible_time_far(3.f);
-				p.delay_time(0.35f);
+				p.delay_time(gSavedSettings.getF32("ObjectInspectorTooltipDelay"));
 				p.wrap(false);
 				
 				LLToolTipMgr::instance().show(p);
@@ -1214,6 +1314,11 @@ void LLToolPie::VisitHomePage(const LLPickInfo& info)
 	}
 }
 
+void LLToolPie::handleSelect()
+{
+	// tool is reselected when app gets focus, etc.
+	mBlockClickToWalk = true;	
+}
 
 void LLToolPie::handleDeselect()
 {
@@ -1228,15 +1333,17 @@ void LLToolPie::handleDeselect()
 
 LLTool* LLToolPie::getOverrideTool(MASK mask)
 {
-	if (mask == MASK_CONTROL)
-	{
-		return LLToolGrab::getInstance();
-	}
-	else if (mask == (MASK_CONTROL | MASK_SHIFT))
+	if (gSavedSettings.getBOOL("EnableGrab"))
 	{
-		return LLToolGrab::getInstance();
+		if (mask == MASK_CONTROL)
+		{
+			return LLToolGrab::getInstance();
+		}
+		else if (mask == (MASK_CONTROL | MASK_SHIFT))
+		{
+			return LLToolGrab::getInstance();
+		}
 	}
-
 	return LLTool::getOverrideTool(mask);
 }
 
@@ -1250,10 +1357,20 @@ void LLToolPie::stopEditing()
 
 void LLToolPie::onMouseCaptureLost()
 {
-	mMouseOutsideSlop = FALSE;
+	stopCameraSteering();
+	mMouseButtonDown = false;
 	handleMediaMouseUp();
 }
 
+void LLToolPie::stopCameraSteering()
+{
+	mMouseOutsideSlop = false;
+}
+
+bool LLToolPie::inCameraSteerMode()
+{
+	return mMouseButtonDown && mMouseOutsideSlop && gSavedSettings.getBOOL("ClickToWalk");
+}
 
 // true if x,y outside small box around start_x,start_y
 BOOL LLToolPie::outsideSlop(S32 x, S32 y, S32 start_x, S32 start_y)
@@ -1331,6 +1448,7 @@ bool LLToolPie::handleMediaClick(const LLPickInfo& pick)
 		{
 			// Make sure keyboard focus is set to the media focus object.
 			gFocusMgr.setKeyboardFocus(LLViewerMediaFocus::getInstance());
+			LLEditMenuHandler::gEditMenuHandler = LLViewerMediaFocus::instance().getFocusedMediaImpl();
 			
 			media_impl->mouseDown(pick.mUVCoords, gKeyboard->currentMask(TRUE));
 			mMediaMouseCaptureID = mep->getMediaID();
@@ -1419,8 +1537,6 @@ bool LLToolPie::handleMediaMouseUp()
 		
 		mMediaMouseCaptureID.setNull();	
 
-		setMouseCapture(FALSE);
-
 		result = true;		
 	}	
 	
@@ -1483,7 +1599,7 @@ static ECursorType cursor_from_parcel_media(U8 click_action)
 
 
 // True if we handled the event.
-BOOL LLToolPie::pickRightMouseDownCallback()
+BOOL LLToolPie::handleRightClickPick()
 {
 	S32 x = mPick.mMousePt.mX;
 	S32 y = mPick.mMousePt.mY;
@@ -1605,10 +1721,173 @@ BOOL LLToolPie::pickRightMouseDownCallback()
 
 void LLToolPie::showVisualContextMenuEffect()
 {
-		// VEFFECT: ShowPie
-		LLHUDEffectSpiral *effectp = (LLHUDEffectSpiral *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_SPHERE, TRUE);
-		effectp->setPositionGlobal(mPick.mPosGlobal);
-		effectp->setColor(LLColor4U(gAgent.getEffectColor()));
-		effectp->setDuration(0.25f);
+	// VEFFECT: ShowPie
+	LLHUDEffectSpiral *effectp = (LLHUDEffectSpiral *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_SPHERE, TRUE);
+	effectp->setPositionGlobal(mPick.mPosGlobal);
+	effectp->setColor(LLColor4U(gAgent.getEffectColor()));
+	effectp->setDuration(0.25f);
+}
+
+typedef enum e_near_far
+{
+	NEAR_INTERSECTION,
+	FAR_INTERSECTION
+} ENearFar;
+
+bool intersect_ray_with_sphere( const LLVector3& ray_pt, const LLVector3& ray_dir, const LLVector3& sphere_center, F32 sphere_radius, e_near_far near_far, LLVector3& intersection_pt)
+{
+	// do ray/sphere intersection by solving quadratic equation
+	LLVector3 sphere_to_ray_start_vec = ray_pt - sphere_center;
+	F32 B = 2.f * ray_dir * sphere_to_ray_start_vec;
+	F32 C = sphere_to_ray_start_vec.lengthSquared() - (sphere_radius * sphere_radius);
+
+	F32 discriminant = B*B - 4.f*C;
+	if (discriminant >= 0.f)
+	{	// intersection detected, now find closest one
+		F32 t0 = (-B - sqrtf(discriminant)) / 2.f;
+
+		if (t0 > 0.f && near_far == NEAR_INTERSECTION)
+		{
+			intersection_pt = ray_pt + ray_dir * t0;
+		}
+		else
+		{
+			F32 t1 = (-B + sqrtf(discriminant)) / 2.f;
+			intersection_pt = ray_pt + ray_dir * t1;
+		}
+		return true;
+	}
+	else
+	{	// no intersection
+		return false;
+	}
+}
+
+void LLToolPie::startCameraSteering()
+{
+	LLFirstUse::notMoving(false);
+	mMouseOutsideSlop = true;
+	mBlockClickToWalk = true;
+
+	if (gAgentCamera.getFocusOnAvatar())
+	{
+		mSteerPick = mPick;
+
+		// handle special cases of steering picks
+		LLViewerObject* avatar_object = mSteerPick.getObject();
+
+		// get pointer to avatar
+		while (avatar_object && !avatar_object->isAvatar())
+		{
+			avatar_object = (LLViewerObject*)avatar_object->getParent();
+		}
+
+		// if clicking on own avatar...
+		if (avatar_object && ((LLVOAvatar*)avatar_object)->isSelf())
+		{
+			// ...project pick point a few meters in front of avatar
+			mSteerPick.mPosGlobal = gAgent.getPositionGlobal() + LLVector3d(LLViewerCamera::instance().getAtAxis()) * 3.0;
+		}
+
+		if (!mSteerPick.isValid())
+		{
+			mSteerPick.mPosGlobal = gAgent.getPosGlobalFromAgent(
+				LLViewerCamera::instance().getOrigin() + gViewerWindow->mouseDirectionGlobal(mSteerPick.mMousePt.mX, mSteerPick.mMousePt.mY) * 100.f);
+		}
+
+		setMouseCapture(TRUE);
+		
+		mMouseSteerX = mMouseDownX;
+		mMouseSteerY = mMouseDownY;
+		const LLVector3 camera_to_rotation_center	= gAgent.getFrameAgent().getOrigin() - LLViewerCamera::instance().getOrigin();
+		const LLVector3 rotation_center_to_pick		= gAgent.getPosAgentFromGlobal(mSteerPick.mPosGlobal) - gAgent.getFrameAgent().getOrigin();
+
+		mClockwise = camera_to_rotation_center * rotation_center_to_pick < 0.f;
+		if (mMouseSteerGrabPoint) { mMouseSteerGrabPoint->markDead(); }
+		mMouseSteerGrabPoint = (LLHUDEffectBlob *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_BLOB, FALSE);
+		mMouseSteerGrabPoint->setPositionGlobal(mSteerPick.mPosGlobal);
+		mMouseSteerGrabPoint->setColor(LLColor4U(170, 210, 190));
+		mMouseSteerGrabPoint->setPixelSize(5);
+		mMouseSteerGrabPoint->setDuration(2.f);
+	}
+}
+
+void LLToolPie::steerCameraWithMouse(S32 x, S32 y)
+{
+	const LLViewerCamera& camera = LLViewerCamera::instance();
+	const LLCoordFrame& rotation_frame = gAgent.getFrameAgent();
+	const LLVector3 pick_pos = gAgent.getPosAgentFromGlobal(mSteerPick.mPosGlobal);
+	const LLVector3 pick_rotation_center = rotation_frame.getOrigin() + parallel_component(pick_pos - rotation_frame.getOrigin(), rotation_frame.getUpAxis());
+	const F32 MIN_ROTATION_RADIUS_FRACTION = 0.2f;
+	const F32 min_rotation_radius = MIN_ROTATION_RADIUS_FRACTION * dist_vec(pick_rotation_center, camera.getOrigin());;
+	const F32 pick_distance_from_rotation_center = llclamp(dist_vec(pick_pos, pick_rotation_center), min_rotation_radius, F32_MAX);
+	const LLVector3 camera_to_rotation_center = pick_rotation_center - camera.getOrigin();
+	const LLVector3 adjusted_camera_pos = LLViewerCamera::instance().getOrigin() + projected_vec(camera_to_rotation_center, rotation_frame.getUpAxis());
+	const F32 camera_distance_from_rotation_center = dist_vec(adjusted_camera_pos, pick_rotation_center);
+
+	LLVector3 mouse_ray = orthogonal_component(gViewerWindow->mouseDirectionGlobal(x, y), rotation_frame.getUpAxis());
+	mouse_ray.normalize();
+
+	LLVector3 old_mouse_ray = orthogonal_component(gViewerWindow->mouseDirectionGlobal(mMouseSteerX, mMouseSteerY), rotation_frame.getUpAxis());
+	old_mouse_ray.normalize();
+
+	F32 yaw_angle;
+	F32 old_yaw_angle;
+	LLVector3 mouse_on_sphere;
+	LLVector3 old_mouse_on_sphere;
+
+	if (intersect_ray_with_sphere(
+			adjusted_camera_pos,
+			mouse_ray,
+			pick_rotation_center,
+			pick_distance_from_rotation_center, 
+			FAR_INTERSECTION,
+			mouse_on_sphere))
+	{
+		LLVector3 mouse_sphere_offset = mouse_on_sphere - pick_rotation_center;
+		yaw_angle = atan2f(mouse_sphere_offset * rotation_frame.getLeftAxis(), mouse_sphere_offset * rotation_frame.getAtAxis());
+	}
+	else
+	{
+		yaw_angle = F_PI_BY_TWO + asinf(pick_distance_from_rotation_center / camera_distance_from_rotation_center);
+		if (mouse_ray * rotation_frame.getLeftAxis() < 0.f)
+		{
+			yaw_angle *= -1.f;
+		}
+	}
+
+	if (intersect_ray_with_sphere(
+			adjusted_camera_pos,
+			old_mouse_ray,
+			pick_rotation_center,
+			pick_distance_from_rotation_center,
+			FAR_INTERSECTION,
+			old_mouse_on_sphere))
+	{
+		LLVector3 mouse_sphere_offset = old_mouse_on_sphere - pick_rotation_center;
+		old_yaw_angle = atan2f(mouse_sphere_offset * rotation_frame.getLeftAxis(), mouse_sphere_offset * rotation_frame.getAtAxis());
+	}
+	else
+	{
+		old_yaw_angle = F_PI_BY_TWO + asinf(pick_distance_from_rotation_center / camera_distance_from_rotation_center);
+
+		if (mouse_ray * rotation_frame.getLeftAxis() < 0.f)
+		{
+			old_yaw_angle *= -1.f;
+		}
+	}
+
+	const F32 delta_angle = yaw_angle - old_yaw_angle;
+
+	if (mClockwise)
+	{
+		gAgent.yaw(delta_angle);
+	}
+	else
+	{
+		gAgent.yaw(-delta_angle);
+	}
 
+	mMouseSteerX = x;
+	mMouseSteerY = y;
 }