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, 2957 insertions, 2956 deletions

diff --git a/indra/newview/llagentcamera.cpp b/indra/newview/llagentcamera.cpp
index a8a4576d42..033805b5ed 100644
--- a/indra/newview/llagentcamera.cpp
+++ b/indra/newview/llagentcamera.cpp
@@ -1,2956 +1,2957 @@
-/** 
- * @file llagentcamera.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 "llagentcamera.h" 
-
-#include "pipeline.h"
-
-#include "llagent.h"
-#include "llanimationstates.h"
-#include "llfloatercamera.h"
-#include "llfloaterreg.h"
-#include "llhudmanager.h"
-#include "lljoystickbutton.h"
-#include "llmorphview.h"
-#include "llmoveview.h"
-#include "llselectmgr.h"
-#include "llsmoothstep.h"
-#include "lltoolmgr.h"
-#include "llviewercamera.h"
-#include "llviewercontrol.h"
-#include "llviewerjoystick.h"
-#include "llviewermenu.h"
-#include "llviewerobjectlist.h"
-#include "llviewerregion.h"
-#include "llviewerwindow.h"
-#include "llvoavatarself.h"
-#include "llwindow.h"
-#include "llworld.h"
-
-using namespace LLAvatarAppearanceDefines;
-
-extern LLMenuBarGL* gMenuBarView;
-
-// Mousewheel camera zoom
-const F32 MIN_ZOOM_FRACTION = 0.25f;
-const F32 INITIAL_ZOOM_FRACTION = 1.f;
-const F32 MAX_ZOOM_FRACTION = 8.f;
-
-const F32 CAMERA_ZOOM_HALF_LIFE = 0.07f;	// seconds
-const F32 FOV_ZOOM_HALF_LIFE = 0.07f;	// seconds
-
-const F32 CAMERA_FOCUS_HALF_LIFE = 0.f;//0.02f;
-const F32 CAMERA_LAG_HALF_LIFE = 0.25f;
-const F32 MIN_CAMERA_LAG = 0.5f;
-const F32 MAX_CAMERA_LAG = 5.f;
-
-const F32 CAMERA_COLLIDE_EPSILON = 0.1f;
-const F32 MIN_CAMERA_DISTANCE = 0.1f;
-
-const F32 AVATAR_ZOOM_MIN_X_FACTOR = 0.55f;
-const F32 AVATAR_ZOOM_MIN_Y_FACTOR = 0.7f;
-const F32 AVATAR_ZOOM_MIN_Z_FACTOR = 1.15f;
-
-const F32 MAX_CAMERA_DISTANCE_FROM_AGENT = 50.f;
-const F32 MAX_CAMERA_DISTANCE_FROM_OBJECT = 496.f;
-const F32 CAMERA_FUDGE_FROM_OBJECT = 16.f;
-
-const F32 MAX_CAMERA_SMOOTH_DISTANCE = 50.0f;
-
-const F32 HEAD_BUFFER_SIZE = 0.3f;
-
-const F32 CUSTOMIZE_AVATAR_CAMERA_ANIM_SLOP = 0.1f;
-
-const F32 LAND_MIN_ZOOM = 0.15f;
-
-const F32 AVATAR_MIN_ZOOM = 0.5f;
-const F32 OBJECT_MIN_ZOOM = 0.02f;
-
-const F32 APPEARANCE_MIN_ZOOM = 0.39f;
-const F32 APPEARANCE_MAX_ZOOM = 8.f;
-
-const F32 CUSTOMIZE_AVATAR_CAMERA_DEFAULT_DIST = 3.5f;
-
-const F32 GROUND_TO_AIR_CAMERA_TRANSITION_TIME = 0.5f;
-const F32 GROUND_TO_AIR_CAMERA_TRANSITION_START_TIME = 0.5f;
-
-const F32 OBJECT_EXTENTS_PADDING = 0.5f;
-
-static bool isDisableCameraConstraints()
-{
-	static LLCachedControl<bool> sDisableCameraConstraints(gSavedSettings, "DisableCameraConstraints", false);
-	return sDisableCameraConstraints;
-}
-
-// The agent instance.
-LLAgentCamera gAgentCamera;
-
-//-----------------------------------------------------------------------------
-// LLAgentCamera()
-//-----------------------------------------------------------------------------
-LLAgentCamera::LLAgentCamera() :
-	mInitialized(false),
-
-	mDrawDistance( DEFAULT_FAR_PLANE ),
-
-	mLookAt(NULL),
-	mPointAt(NULL),
-
-	mHUDTargetZoom(1.f),
-	mHUDCurZoom(1.f),
-
-	mForceMouselook(false),
-
-	mCameraMode( CAMERA_MODE_THIRD_PERSON ),
-	mLastCameraMode( CAMERA_MODE_THIRD_PERSON ),
-
-	mCameraPreset(CAMERA_PRESET_REAR_VIEW),
-
-	mCameraAnimating( false ),
-	mAnimationCameraStartGlobal(),
-	mAnimationFocusStartGlobal(),
-	mAnimationTimer(),
-	mAnimationDuration(0.33f),
-	
-	mCameraFOVZoomFactor(0.f),
-	mCameraCurrentFOVZoomFactor(0.f),
-	mCameraFocusOffset(),
-
-	mCameraCollidePlane(),
-
-	mCurrentCameraDistance(2.f),		// meters, set in init()
-	mTargetCameraDistance(2.f),
-	mCameraZoomFraction(1.f),			// deprecated
-	mThirdPersonHeadOffset(0.f, 0.f, 1.f),
-	mSitCameraEnabled(false),
-	mCameraSmoothingLastPositionGlobal(),
-	mCameraSmoothingLastPositionAgent(),
-	mCameraSmoothingStop(false),
-
-	mCameraUpVector(LLVector3::z_axis), // default is straight up
-
-	mFocusOnAvatar(true),
-	mAllowChangeToFollow(false),
-	mFocusGlobal(),
-	mFocusTargetGlobal(),
-	mFocusObject(NULL),
-	mFocusObjectDist(0.f),
-	mFocusObjectOffset(),
-	mTrackFocusObject(true),
-
-	mAtKey(0), // Either 1, 0, or -1... indicates that movement-key is pressed
-	mWalkKey(0), // like AtKey, but causes less forward thrust
-	mLeftKey(0),
-	mUpKey(0),
-	mYawKey(0.f),
-	mPitchKey(0.f),
-
-	mOrbitLeftKey(0.f),
-	mOrbitRightKey(0.f),
-	mOrbitUpKey(0.f),
-	mOrbitDownKey(0.f),
-	mOrbitInKey(0.f),
-	mOrbitOutKey(0.f),
-
-	mPanUpKey(0.f),
-	mPanDownKey(0.f),
-	mPanLeftKey(0.f),
-	mPanRightKey(0.f),
-	mPanInKey(0.f),
-	mPanOutKey(0.f)
-{
-	mFollowCam.setMaxCameraDistantFromSubject( MAX_CAMERA_DISTANCE_FROM_AGENT );
-
-	clearGeneralKeys();
-	clearOrbitKeys();
-	clearPanKeys();
-
-	resetPanDiff();
-	resetOrbitDiff();
-}
-
-// Requires gSavedSettings to be initialized.
-//-----------------------------------------------------------------------------
-// init()
-//-----------------------------------------------------------------------------
-void LLAgentCamera::init()
-{
-	// *Note: this is where LLViewerCamera::getInstance() used to be constructed.
-
-	mDrawDistance = gSavedSettings.getF32("RenderFarClip");
-
-	LLViewerCamera::getInstance()->setView(DEFAULT_FIELD_OF_VIEW);
-	// Leave at 0.1 meters until we have real near clip management
-	LLViewerCamera::getInstance()->setNear(0.1f);
-	LLViewerCamera::getInstance()->setFar(mDrawDistance);			// if you want to change camera settings, do so in camera.h
-	LLViewerCamera::getInstance()->setAspect( gViewerWindow->getWorldViewAspectRatio() );		// default, overridden in LLViewerWindow::reshape
-	LLViewerCamera::getInstance()->setViewHeightInPixels(768);			// default, overridden in LLViewerWindow::reshape
-
-	mCameraFocusOffsetTarget = LLVector4(gSavedSettings.getVector3("CameraOffsetBuild"));
-	
-	mCameraPreset = (ECameraPreset) gSavedSettings.getU32("CameraPresetType");
-
-	mCameraCollidePlane.clearVec();
-	mCurrentCameraDistance = getCameraOffsetInitial().magVec() * gSavedSettings.getF32("CameraOffsetScale");
-	mTargetCameraDistance = mCurrentCameraDistance;
-	mCameraZoomFraction = 1.f;
-	mTrackFocusObject = gSavedSettings.getBOOL("TrackFocusObject");
-
-	mInitialized = true;
-}
-
-//-----------------------------------------------------------------------------
-// cleanup()
-//-----------------------------------------------------------------------------
-void LLAgentCamera::cleanup()
-{
-	setSitCamera(LLUUID::null);
-
-	if(mLookAt)
-	{
-		mLookAt->markDead() ;
-		mLookAt = NULL;
-	}
-	if(mPointAt)
-	{
-		mPointAt->markDead() ;
-		mPointAt = NULL;
-	}
-	setFocusObject(NULL);
-}
-
-void LLAgentCamera::setAvatarObject(LLVOAvatarSelf* avatar)
-{
-	if (!mLookAt)
-	{
-		mLookAt = (LLHUDEffectLookAt *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_LOOKAT);
-	}
-	if (!mPointAt)
-	{
-		mPointAt = (LLHUDEffectPointAt *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_POINTAT);
-	}
-	
-	if (!mLookAt.isNull())
-	{
-		mLookAt->setSourceObject(avatar);
-	}
-	if (!mPointAt.isNull())
-	{
-		mPointAt->setSourceObject(avatar);
-	}	
-}
-
-//-----------------------------------------------------------------------------
-// LLAgent()
-//-----------------------------------------------------------------------------
-LLAgentCamera::~LLAgentCamera()
-{
-	cleanup();
-
-	// *Note: this is where LLViewerCamera::getInstance() used to be deleted.
-}
-
-// Change camera back to third person, stop the autopilot,
-// deselect stuff, etc.
-//-----------------------------------------------------------------------------
-// resetView()
-//-----------------------------------------------------------------------------
-void LLAgentCamera::resetView(bool reset_camera, bool change_camera)
-{
-	if (gDisconnected)
-	{
-		return;
-	}
-
-	if (gAgent.getAutoPilot())
-	{
-		gAgent.stopAutoPilot(true);
-	}
-
-	LLSelectMgr::getInstance()->unhighlightAll();
-
-	// By popular request, keep land selection while walking around. JC
-	// LLViewerParcelMgr::getInstance()->deselectLand();
-
-	// force deselect when walking and attachment is selected
-	// this is so people don't wig out when their avatar moves without animating
-	if (LLSelectMgr::getInstance()->getSelection()->isAttachment())
-	{
-		LLSelectMgr::getInstance()->deselectAll();
-	}
-
-	if (gMenuHolder != NULL)
-	{
-		// Hide all popup menus
-		gMenuHolder->hideMenus();
-	}
-
-	if (change_camera && !gSavedSettings.getBOOL("FreezeTime"))
-	{
-		changeCameraToDefault();
-		
-		if (LLViewerJoystick::getInstance()->getOverrideCamera())
-		{
-			handle_toggle_flycam();
-		}
-
-		// reset avatar mode from eventual residual motion
-		if (LLToolMgr::getInstance()->inBuildMode())
-		{
-			LLViewerJoystick::getInstance()->moveAvatar(true);
-		}
-
-		//Camera Tool is needed for Free Camera Control Mode
-		if (!LLFloaterCamera::inFreeCameraMode())
-		{
-			LLFloaterReg::hideInstance("build");
-
-			// Switch back to basic toolset
-			LLToolMgr::getInstance()->setCurrentToolset(gBasicToolset);
-		}
-		
-		gViewerWindow->showCursor();
-	}
-
-
-	if (reset_camera && !gSavedSettings.getBOOL("FreezeTime"))
-	{
-		if (!gViewerWindow->getLeftMouseDown() && cameraThirdPerson())
-		{
-			// leaving mouse-steer mode
-			LLVector3 agent_at_axis = gAgent.getAtAxis();
-			agent_at_axis -= projected_vec(agent_at_axis, gAgent.getReferenceUpVector());
-			agent_at_axis.normalize();
-			gAgent.resetAxes(lerp(gAgent.getAtAxis(), agent_at_axis, LLSmoothInterpolation::getInterpolant(0.3f)));
-		}
-
-		setFocusOnAvatar(true, ANIMATE);
-
-		mCameraFOVZoomFactor = 0.f;
-	}
-	resetPanDiff();
-	resetOrbitDiff();
-	mHUDTargetZoom = 1.f;
-
-    if (LLSelectMgr::getInstance()->mAllowSelectAvatar)
-    {
-        // resetting camera also resets position overrides in debug mode 'AllowSelectAvatar'
-        LLObjectSelectionHandle selected_handle = LLSelectMgr::getInstance()->getSelection();
-        if (selected_handle->getObjectCount() == 1
-            && selected_handle->getFirstObject() != NULL
-            && selected_handle->getFirstObject()->isAvatar())
-        {
-            LLSelectMgr::getInstance()->resetObjectOverrides(selected_handle);
-        }
-    }
-}
-
-// Allow camera to be moved somewhere other than behind avatar.
-//-----------------------------------------------------------------------------
-// unlockView()
-//-----------------------------------------------------------------------------
-void LLAgentCamera::unlockView()
-{
-	if (getFocusOnAvatar())
-	{
-		if (isAgentAvatarValid())
-		{
-			setFocusGlobal(LLVector3d::zero, gAgentAvatarp->mID);
-		}
-		setFocusOnAvatar(false, false);	// no animation
-	}
-}
-
-//-----------------------------------------------------------------------------
-// slamLookAt()
-//-----------------------------------------------------------------------------
-void LLAgentCamera::slamLookAt(const LLVector3 &look_at)
-{
-	LLVector3 look_at_norm = look_at;
-	look_at_norm.mV[VZ] = 0.f;
-	look_at_norm.normalize();
-	gAgent.resetAxes(look_at_norm);
-}
-
-//-----------------------------------------------------------------------------
-// calcFocusOffset()
-//-----------------------------------------------------------------------------
-LLVector3 LLAgentCamera::calcFocusOffset(LLViewerObject *object, LLVector3 original_focus_point, S32 x, S32 y)
-{
-	LLMatrix4 obj_matrix = object->getRenderMatrix();
-	LLQuaternion obj_rot = object->getRenderRotation();
-	LLVector3 obj_pos = object->getRenderPosition();
-
-	// if is avatar - don't do any funk heuristics to position the focal point
-	// see DEV-30589
-	if ((object->isAvatar() && !object->isRoot()) || (object->isAnimatedObject() && object->getControlAvatar()))
-	{
-		return original_focus_point - obj_pos;
-	}
-    if (object->isAvatar())
-    {
-        LLVOAvatar* av = object->asAvatar();
-        return original_focus_point - av->getCharacterPosition();
-    }
-	
-	LLQuaternion inv_obj_rot = ~obj_rot; // get inverse of rotation
-	LLVector3 object_extents = object->getScale();	
-	
-	// make sure they object extents are non-zero
-	object_extents.clamp(0.001f, F32_MAX);
-
-	// obj_to_cam_ray is unit vector pointing from object center to camera, in the coordinate frame of the object
-	LLVector3 obj_to_cam_ray = obj_pos - LLViewerCamera::getInstance()->getOrigin();
-	obj_to_cam_ray.rotVec(inv_obj_rot);
-	obj_to_cam_ray.normalize();
-
-	// obj_to_cam_ray_proportions are the (positive) ratios of 
-	// the obj_to_cam_ray x,y,z components with the x,y,z object dimensions.
-	LLVector3 obj_to_cam_ray_proportions;
-	obj_to_cam_ray_proportions.mV[VX] = llabs(obj_to_cam_ray.mV[VX] / object_extents.mV[VX]);
-	obj_to_cam_ray_proportions.mV[VY] = llabs(obj_to_cam_ray.mV[VY] / object_extents.mV[VY]);
-	obj_to_cam_ray_proportions.mV[VZ] = llabs(obj_to_cam_ray.mV[VZ] / object_extents.mV[VZ]);
-
-	// find the largest ratio stored in obj_to_cam_ray_proportions
-	// this corresponds to the object's local axial plane (XY, YZ, XZ) that is *most* facing the camera
-	LLVector3 longest_object_axis;
-	// is x-axis longest?
-	if (obj_to_cam_ray_proportions.mV[VX] > obj_to_cam_ray_proportions.mV[VY] 
-		&& obj_to_cam_ray_proportions.mV[VX] > obj_to_cam_ray_proportions.mV[VZ])
-	{
-		// then grab it
-		longest_object_axis.setVec(obj_matrix.getFwdRow4());
-	}
-	// is y-axis longest?
-	else if (obj_to_cam_ray_proportions.mV[VY] > obj_to_cam_ray_proportions.mV[VZ])
-	{
-		// then grab it
-		longest_object_axis.setVec(obj_matrix.getLeftRow4());
-	}
-	// otherwise, use z axis
-	else
-	{
-		longest_object_axis.setVec(obj_matrix.getUpRow4());
-	}
-
-	// Use this axis as the normal to project mouse click on to plane with that normal, at the object center.
-	// This generates a point behind the mouse cursor that is approximately in the middle of the object in
-	// terms of depth.  
-	// We do this to allow the camera rotation tool to "tumble" the object by rotating the camera.
-	// If the focus point were the object surface under the mouse, camera rotation would introduce an undesirable
-	// eccentricity to the object orientation
-	LLVector3 focus_plane_normal(longest_object_axis);
-	focus_plane_normal.normalize();
-
-	LLVector3d focus_pt_global;
-	gViewerWindow->mousePointOnPlaneGlobal(focus_pt_global, x, y, gAgent.getPosGlobalFromAgent(obj_pos), focus_plane_normal);
-	LLVector3 focus_pt = gAgent.getPosAgentFromGlobal(focus_pt_global);
-
-	// find vector from camera to focus point in object space
-	LLVector3 camera_to_focus_vec = focus_pt - LLViewerCamera::getInstance()->getOrigin();
-	camera_to_focus_vec.rotVec(inv_obj_rot);
-
-	// find vector from object origin to focus point in object coordinates
-	LLVector3 focus_offset_from_object_center = focus_pt - obj_pos;
-	// convert to object-local space
-	focus_offset_from_object_center.rotVec(inv_obj_rot);
-
-	// We need to project the focus point back into the bounding box of the focused object.
-	// Do this by calculating the XYZ scale factors needed to get focus offset back in bounds along the camera_focus axis
-	LLVector3 clip_fraction;
-
-	// for each axis...
-	for (U32 axis = VX; axis <= VZ; axis++)
-	{
-		//...calculate distance that focus offset sits outside of bounding box along that axis...
-		//NOTE: dist_out_of_bounds keeps the sign of focus_offset_from_object_center 
-		F32 dist_out_of_bounds;
-		if (focus_offset_from_object_center.mV[axis] > 0.f)
-		{
-			dist_out_of_bounds = llmax(0.f, focus_offset_from_object_center.mV[axis] - (object_extents.mV[axis] * 0.5f));
-		}
-		else
-		{
-			dist_out_of_bounds = llmin(0.f, focus_offset_from_object_center.mV[axis] + (object_extents.mV[axis] * 0.5f));
-		}
-
-		//...then calculate the scale factor needed to push camera_to_focus_vec back in bounds along current axis
-		if (llabs(camera_to_focus_vec.mV[axis]) < 0.0001f)
-		{
-			// don't divide by very small number
-			clip_fraction.mV[axis] = 0.f;
-		}
-		else
-		{
-			clip_fraction.mV[axis] = dist_out_of_bounds / camera_to_focus_vec.mV[axis];
-		}
-	}
-
-	LLVector3 abs_clip_fraction = clip_fraction;
-	abs_clip_fraction.abs();
-
-	// find axis of focus offset that is *most* outside the bounding box and use that to
-	// rescale focus offset to inside object extents
-	if (abs_clip_fraction.mV[VX] > abs_clip_fraction.mV[VY]
-		&& abs_clip_fraction.mV[VX] > abs_clip_fraction.mV[VZ])
-	{
-		focus_offset_from_object_center -= clip_fraction.mV[VX] * camera_to_focus_vec;
-	}
-	else if (abs_clip_fraction.mV[VY] > abs_clip_fraction.mV[VZ])
-	{
-		focus_offset_from_object_center -= clip_fraction.mV[VY] * camera_to_focus_vec;
-	}
-	else
-	{
-		focus_offset_from_object_center -= clip_fraction.mV[VZ] * camera_to_focus_vec;
-	}
-
-	// convert back to world space
-	focus_offset_from_object_center.rotVec(obj_rot);
-	
-	// now, based on distance of camera from object relative to object size
-	// push the focus point towards the near surface of the object when (relatively) close to the objcet
-	// or keep the focus point in the object middle when (relatively) far
-	// NOTE: leave focus point in middle of avatars, since the behavior you want when alt-zooming on avatars
-	// is almost always "tumble about middle" and not "spin around surface point"
-	{
-		LLVector3 obj_rel = original_focus_point - object->getRenderPosition();
-		
-		//now that we have the object relative position, we should bias toward the center of the object 
-		//based on the distance of the camera to the focus point vs. the distance of the camera to the focus
-
-		F32 relDist = llabs(obj_rel * LLViewerCamera::getInstance()->getAtAxis());
-		F32 viewDist = dist_vec(obj_pos + obj_rel, LLViewerCamera::getInstance()->getOrigin());
-
-
-		LLBBox obj_bbox = object->getBoundingBoxAgent();
-		F32 bias = 0.f;
-
-		// virtual_camera_pos is the camera position we are simulating by backing the camera off
-		// and adjusting the FOV
-		LLVector3 virtual_camera_pos = gAgent.getPosAgentFromGlobal(mFocusTargetGlobal + (getCameraPositionGlobal() - mFocusTargetGlobal) / (1.f + mCameraFOVZoomFactor));
-
-		// if the camera is inside the object (large, hollow objects, for example)
-		// leave focus point all the way to destination depth, away from object center
-		if(!obj_bbox.containsPointAgent(virtual_camera_pos))
-		{
-			// perform magic number biasing of focus point towards surface vs. planar center
-			bias = clamp_rescale(relDist/viewDist, 0.1f, 0.7f, 0.0f, 1.0f);
-			obj_rel = lerp(focus_offset_from_object_center, obj_rel, bias);
-		}
-			
-		focus_offset_from_object_center = obj_rel;
-	}
-
-	return focus_offset_from_object_center;
-}
-
-//-----------------------------------------------------------------------------
-// calcCameraMinDistance()
-//-----------------------------------------------------------------------------
-bool LLAgentCamera::calcCameraMinDistance(F32 &obj_min_distance)
-{
-	bool soft_limit = false; // is the bounding box to be treated literally (volumes) or as an approximation (avatars)
-
-	if (!mFocusObject || mFocusObject->isDead() ||
-		mFocusObject->isMesh() ||
-		isDisableCameraConstraints())
-	{
-		obj_min_distance = 0.f;
-		return true;
-	}
-
-	if (mFocusObject->mDrawable.isNull())
-	{
-#ifdef LL_RELEASE_FOR_DOWNLOAD
-		LL_WARNS() << "Focus object with no drawable!" << LL_ENDL;
-#else
-		mFocusObject->dump();
-		LL_ERRS() << "Focus object with no drawable!" << LL_ENDL;
-#endif
-		obj_min_distance = 0.f;
-		return true;
-	}
-	
-	LLQuaternion inv_object_rot = ~mFocusObject->getRenderRotation();
-	LLVector3 target_offset_origin = mFocusObjectOffset;
-	LLVector3 camera_offset_target(getCameraPositionAgent() - gAgent.getPosAgentFromGlobal(mFocusTargetGlobal));
-
-	// convert offsets into object local space
-	camera_offset_target.rotVec(inv_object_rot);
-	target_offset_origin.rotVec(inv_object_rot);
-
-	// push around object extents based on target offset
-	LLVector3 object_extents = mFocusObject->getScale();
-	if (mFocusObject->isAvatar())
-	{
-		// fudge factors that lets you zoom in on avatars a bit more (which don't do FOV zoom)
-		object_extents.mV[VX] *= AVATAR_ZOOM_MIN_X_FACTOR;
-		object_extents.mV[VY] *= AVATAR_ZOOM_MIN_Y_FACTOR;
-		object_extents.mV[VZ] *= AVATAR_ZOOM_MIN_Z_FACTOR;
-		soft_limit = true;
-	}
-	LLVector3 abs_target_offset = target_offset_origin;
-	abs_target_offset.abs();
-
-	LLVector3 target_offset_dir = target_offset_origin;
-
-	bool target_outside_object_extents = false;
-
-	for (U32 i = VX; i <= VZ; i++)
-	{
-		if (abs_target_offset.mV[i] * 2.f > object_extents.mV[i] + OBJECT_EXTENTS_PADDING)
-		{
-			target_outside_object_extents = true;
-		}
-		if (camera_offset_target.mV[i] > 0.f)
-		{
-			object_extents.mV[i] -= target_offset_origin.mV[i] * 2.f;
-		}
-		else
-		{
-			object_extents.mV[i] += target_offset_origin.mV[i] * 2.f;
-		}
-	}
-
-	// don't shrink the object extents so far that the object inverts
-	object_extents.clamp(0.001f, F32_MAX);
-
-	// move into first octant
-	LLVector3 camera_offset_target_abs_norm = camera_offset_target;
-	camera_offset_target_abs_norm.abs();
-	// make sure offset is non-zero
-	camera_offset_target_abs_norm.clamp(0.001f, F32_MAX);
-	camera_offset_target_abs_norm.normalize();
-
-	// find camera position relative to normalized object extents
-	LLVector3 camera_offset_target_scaled = camera_offset_target_abs_norm;
-	camera_offset_target_scaled.mV[VX] /= object_extents.mV[VX];
-	camera_offset_target_scaled.mV[VY] /= object_extents.mV[VY];
-	camera_offset_target_scaled.mV[VZ] /= object_extents.mV[VZ];
-
-	if (camera_offset_target_scaled.mV[VX] > camera_offset_target_scaled.mV[VY] && 
-		camera_offset_target_scaled.mV[VX] > camera_offset_target_scaled.mV[VZ])
-	{
-		if (camera_offset_target_abs_norm.mV[VX] < 0.001f)
-		{
-			obj_min_distance = object_extents.mV[VX] * 0.5f;
-		}
-		else
-		{
-			obj_min_distance = object_extents.mV[VX] * 0.5f / camera_offset_target_abs_norm.mV[VX];
-		}
-	}
-	else if (camera_offset_target_scaled.mV[VY] > camera_offset_target_scaled.mV[VZ])
-	{
-		if (camera_offset_target_abs_norm.mV[VY] < 0.001f)
-		{
-			obj_min_distance = object_extents.mV[VY] * 0.5f;
-		}
-		else
-		{
-			obj_min_distance = object_extents.mV[VY] * 0.5f / camera_offset_target_abs_norm.mV[VY];
-		}
-	}
-	else
-	{
-		if (camera_offset_target_abs_norm.mV[VZ] < 0.001f)
-		{
-			obj_min_distance = object_extents.mV[VZ] * 0.5f;
-		}
-		else
-		{
-			obj_min_distance = object_extents.mV[VZ] * 0.5f / camera_offset_target_abs_norm.mV[VZ];
-		}
-	}
-
-	LLVector3 object_split_axis;
-	LLVector3 target_offset_scaled = target_offset_origin;
-	target_offset_scaled.abs();
-	target_offset_scaled.normalize();
-	target_offset_scaled.mV[VX] /= object_extents.mV[VX];
-	target_offset_scaled.mV[VY] /= object_extents.mV[VY];
-	target_offset_scaled.mV[VZ] /= object_extents.mV[VZ];
-
-	if (target_offset_scaled.mV[VX] > target_offset_scaled.mV[VY] && 
-		target_offset_scaled.mV[VX] > target_offset_scaled.mV[VZ])
-	{
-		object_split_axis = LLVector3::x_axis;
-	}
-	else if (target_offset_scaled.mV[VY] > target_offset_scaled.mV[VZ])
-	{
-		object_split_axis = LLVector3::y_axis;
-	}
-	else
-	{
-		object_split_axis = LLVector3::z_axis;
-	}
-
-	LLVector3 camera_offset_object(getCameraPositionAgent() - mFocusObject->getPositionAgent());
-
-
-	F32 camera_offset_clip = camera_offset_object * object_split_axis;
-	F32 target_offset_clip = target_offset_dir * object_split_axis;
-
-	// target has moved outside of object extents
-	// check to see if camera and target are on same side 
-	if (target_outside_object_extents)
-	{
-		if (camera_offset_clip > 0.f && target_offset_clip > 0.f)
-		{
-			return false;
-		}
-		else if (camera_offset_clip < 0.f && target_offset_clip < 0.f)
-		{
-			return false;
-		}
-	}
-
-	// clamp obj distance to diagonal of 10 by 10 cube
-	obj_min_distance = llmin(obj_min_distance, 10.f * F_SQRT3);
-
-	obj_min_distance += LLViewerCamera::getInstance()->getNear() + (soft_limit ? 0.1f : 0.2f);
-	
-	return true;
-}
-
-F32 LLAgentCamera::getCameraZoomFraction(bool get_third_person)
-{
-	// 0.f -> camera zoomed all the way out
-	// 1.f -> camera zoomed all the way in
-	LLObjectSelectionHandle selection = LLSelectMgr::getInstance()->getSelection();
-	if (selection->getObjectCount() && selection->getSelectType() == SELECT_TYPE_HUD)
-	{
-		// already [0,1]
-		return mHUDTargetZoom;
-	}
-
-	if (get_third_person || (mFocusOnAvatar && cameraThirdPerson()))
-	{
-		return clamp_rescale(mCameraZoomFraction, MIN_ZOOM_FRACTION, MAX_ZOOM_FRACTION, 1.f, 0.f);
-	}
-
-	if (cameraCustomizeAvatar())
-	{
-		F32 distance = (F32)mCameraFocusOffsetTarget.magVec();
-		return clamp_rescale(distance, APPEARANCE_MIN_ZOOM, APPEARANCE_MAX_ZOOM, 1.f, 0.f );
-	}
-
-	F32 min_zoom;
-	F32 max_zoom = getCameraMaxZoomDistance();
-    if (isDisableCameraConstraints())
-    {
-        max_zoom = MAX_CAMERA_DISTANCE_FROM_OBJECT;
-    }
-
-	F32 distance = (F32)mCameraFocusOffsetTarget.magVec();
-	if (mFocusObject.notNull())
-	{
-		if (mFocusObject->isAvatar())
-		{
-			min_zoom = AVATAR_MIN_ZOOM;
-		}
-		else
-		{
-			min_zoom = OBJECT_MIN_ZOOM;
-		}
-	}
-	else
-	{
-		min_zoom = LAND_MIN_ZOOM;
-	}
-
-	return clamp_rescale(distance, min_zoom, max_zoom, 1.f, 0.f);
-}
-
-void LLAgentCamera::setCameraZoomFraction(F32 fraction)
-{
-	// 0.f -> camera zoomed all the way out
-	// 1.f -> camera zoomed all the way in
-	LLObjectSelectionHandle selection = LLSelectMgr::getInstance()->getSelection();
-
-	if (selection->getObjectCount() && selection->getSelectType() == SELECT_TYPE_HUD)
-	{
-		mHUDTargetZoom = fraction;
-	}
-	else if (mFocusOnAvatar && cameraThirdPerson())
-	{
-		mCameraZoomFraction = rescale(fraction, 0.f, 1.f, MAX_ZOOM_FRACTION, MIN_ZOOM_FRACTION);
-	}
-	else if (cameraCustomizeAvatar())
-	{
-		LLVector3d camera_offset_dir = mCameraFocusOffsetTarget;
-		camera_offset_dir.normalize();
-		mCameraFocusOffsetTarget = camera_offset_dir * rescale(fraction, 0.f, 1.f, APPEARANCE_MAX_ZOOM, APPEARANCE_MIN_ZOOM);
-	}
-	else
-	{
-		F32 min_zoom = LAND_MIN_ZOOM;
-		F32 max_zoom = getCameraMaxZoomDistance();
-        if (isDisableCameraConstraints())
-        {
-            max_zoom = MAX_CAMERA_DISTANCE_FROM_OBJECT;
-        }
-
-		if (mFocusObject.notNull())
-		{
-			if (mFocusObject.notNull())
-			{
-				if (mFocusObject->isAvatar())
-				{
-					min_zoom = AVATAR_MIN_ZOOM;
-				}
-				else
-				{
-					min_zoom = OBJECT_MIN_ZOOM;
-				}
-			}
-		}
-
-		LLVector3d camera_offset_dir = mCameraFocusOffsetTarget;
-		camera_offset_dir.normalize();
-		mCameraFocusOffsetTarget = camera_offset_dir * rescale(fraction, 0.f, 1.f, max_zoom, min_zoom);
-	}
-
-	startCameraAnimation();
-}
-
-F32 LLAgentCamera::getAgentHUDTargetZoom()
-{
-	static LLCachedControl<F32> hud_scale_factor(gSavedSettings, "HUDScaleFactor");
-	LLObjectSelectionHandle selection = LLSelectMgr::getInstance()->getSelection();
-	return (selection->getObjectCount() && selection->getSelectType() == SELECT_TYPE_HUD) ? hud_scale_factor*gAgentCamera.mHUDTargetZoom : hud_scale_factor;
-}
-
-//-----------------------------------------------------------------------------
-// cameraOrbitAround()
-//-----------------------------------------------------------------------------
-void LLAgentCamera::cameraOrbitAround(const F32 radians)
-{
-	LLObjectSelectionHandle selection = LLSelectMgr::getInstance()->getSelection();
-	if (selection->getObjectCount() && selection->getSelectType() == SELECT_TYPE_HUD)
-	{
-		// do nothing for hud selection
-	}
-	else if (mFocusOnAvatar && (mCameraMode == CAMERA_MODE_THIRD_PERSON || mCameraMode == CAMERA_MODE_FOLLOW))
-	{
-		gAgent.yaw(radians);
-	}
-	else
-	{
-		mOrbitAroundRadians += radians;
-		mCameraFocusOffsetTarget.rotVec(radians, 0.f, 0.f, 1.f);
-		
-		cameraZoomIn(1.f);
-	}
-}
-
-
-//-----------------------------------------------------------------------------
-// cameraOrbitOver()
-//-----------------------------------------------------------------------------
-void LLAgentCamera::cameraOrbitOver(const F32 angle)
-{
-	LLObjectSelectionHandle selection = LLSelectMgr::getInstance()->getSelection();
-	if (selection->getObjectCount() && selection->getSelectType() == SELECT_TYPE_HUD)
-	{
-		// do nothing for hud selection
-	}
-	else if (mFocusOnAvatar && mCameraMode == CAMERA_MODE_THIRD_PERSON)
-	{
-		gAgent.pitch(angle);
-	}
-	else
-	{
-		LLVector3 camera_offset_unit(mCameraFocusOffsetTarget);
-		camera_offset_unit.normalize();
-
-		F32 angle_from_up = acos( camera_offset_unit * gAgent.getReferenceUpVector() );
-
-		LLVector3d left_axis;
-		left_axis.setVec(LLViewerCamera::getInstance()->getLeftAxis());
-		F32 new_angle = llclamp(angle_from_up - angle, 1.f * DEG_TO_RAD, 179.f * DEG_TO_RAD);
-		mOrbitOverAngle += angle_from_up - new_angle;
-		mCameraFocusOffsetTarget.rotVec(angle_from_up - new_angle, left_axis);
-
-		cameraZoomIn(1.f);
-	}
-}
-
-void LLAgentCamera::resetCameraOrbit()
-{
-	LLVector3 camera_offset_unit(mCameraFocusOffsetTarget);
-	camera_offset_unit.normalize();
-
-	LLVector3d left_axis;
-	left_axis.setVec(LLViewerCamera::getInstance()->getLeftAxis());
-	mCameraFocusOffsetTarget.rotVec(-mOrbitOverAngle, left_axis);
-	
-	mCameraFocusOffsetTarget.rotVec(-mOrbitAroundRadians, 0.f, 0.f, 1.f);
-
-	cameraZoomIn(1.f);
-	resetOrbitDiff();
-}
-
-void LLAgentCamera::resetOrbitDiff()
-{
-	mOrbitAroundRadians = 0;
-	mOrbitOverAngle = 0;
-}
-
-//-----------------------------------------------------------------------------
-// cameraZoomIn()
-//-----------------------------------------------------------------------------
-void LLAgentCamera::cameraZoomIn(const F32 fraction)
-{
-	if (gDisconnected)
-	{
-		return;
-	}
-
-	LLObjectSelectionHandle selection = LLSelectMgr::getInstance()->getSelection();
-	if (LLToolMgr::getInstance()->inBuildMode() && selection->getObjectCount() && selection->getSelectType() == SELECT_TYPE_HUD)
-	{
-		// just update hud zoom level
-		mHUDTargetZoom /= fraction;
-		return;
-	}
-
-	LLVector3d camera_offset_unit(mCameraFocusOffsetTarget);
-	F32 current_distance = (F32)camera_offset_unit.normalize();
-	F32 new_distance = current_distance * fraction;
-
-	// Unless camera is unlocked
-	if (!isDisableCameraConstraints())
-	{
-		F32 min_zoom = LAND_MIN_ZOOM;
-
-		// Don't move through focus point
-		if (mFocusObject)
-		{
-			LLVector3 camera_offset_dir((F32)camera_offset_unit.mdV[VX], (F32)camera_offset_unit.mdV[VY], (F32)camera_offset_unit.mdV[VZ]);
-
-			if (mFocusObject->isAvatar())
-			{
-				calcCameraMinDistance(min_zoom);
-			}
-			else
-			{
-				min_zoom = OBJECT_MIN_ZOOM;
-			}
-		}
-
-		new_distance = llmax(new_distance, min_zoom);
-
-		F32 max_distance = getCameraMaxZoomDistance();
-		max_distance = llmin(max_distance, current_distance * 4.f); //Scaled max relative to current distance.  MAINT-3154
-		new_distance = llmin(new_distance, max_distance);
-
-		if (cameraCustomizeAvatar())
-		{
-			new_distance = llclamp(new_distance, APPEARANCE_MIN_ZOOM, APPEARANCE_MAX_ZOOM);
-		}
-	}
-
-	mCameraFocusOffsetTarget = new_distance * camera_offset_unit;
-}
-
-//-----------------------------------------------------------------------------
-// cameraOrbitIn()
-//-----------------------------------------------------------------------------
-void LLAgentCamera::cameraOrbitIn(const F32 meters)
-{
-	if (mFocusOnAvatar && mCameraMode == CAMERA_MODE_THIRD_PERSON)
-	{
-		F32 camera_offset_dist = llmax(0.001f, getCameraOffsetInitial().magVec() * gSavedSettings.getF32("CameraOffsetScale"));
-		
-		mCameraZoomFraction = (mTargetCameraDistance - meters) / camera_offset_dist;
-
-		if (!gSavedSettings.getBOOL("FreezeTime") && mCameraZoomFraction < MIN_ZOOM_FRACTION && meters > 0.f)
-		{
-			// No need to animate, camera is already there.
-			changeCameraToMouselook(false);
-		}
-
-		if (!isDisableCameraConstraints())
-		{
-			mCameraZoomFraction = llclamp(mCameraZoomFraction, MIN_ZOOM_FRACTION, MAX_ZOOM_FRACTION);
-		}
-	}
-	else
-	{
-		LLVector3d	camera_offset_unit(mCameraFocusOffsetTarget);
-		F32 current_distance = (F32)camera_offset_unit.normalize();
-		F32 new_distance = current_distance - meters;
-
-		// Unless camera is unlocked
-		if (!isDisableCameraConstraints())
-		{
-			F32 min_zoom = LAND_MIN_ZOOM;
-
-			// Don't move through focus point
-			if (mFocusObject.notNull())
-			{
-				if (mFocusObject->isAvatar())
-				{
-					min_zoom = AVATAR_MIN_ZOOM;
-				}
-				else
-				{
-					min_zoom = OBJECT_MIN_ZOOM;
-				}
-			}
-
-			new_distance = llmax(new_distance, min_zoom);
-
-			F32 max_distance = getCameraMaxZoomDistance();
-			new_distance = llmin(new_distance, max_distance);
-
-			if (CAMERA_MODE_CUSTOMIZE_AVATAR == getCameraMode())
-			{
-				new_distance = llclamp(new_distance, APPEARANCE_MIN_ZOOM, APPEARANCE_MAX_ZOOM);
-			}
-		}
-
-		// Compute new camera offset
-		mCameraFocusOffsetTarget = new_distance * camera_offset_unit;
-		cameraZoomIn(1.f);
-	}
-}
-
-//-----------------------------------------------------------------------------
-// cameraPanIn()
-//-----------------------------------------------------------------------------
-void LLAgentCamera::cameraPanIn(F32 meters)
-{
-	LLVector3d at_axis;
-	at_axis.setVec(LLViewerCamera::getInstance()->getAtAxis());
-
-	mPanFocusDiff += meters * at_axis;
-
-	mFocusTargetGlobal += meters * at_axis;
-	mFocusGlobal = mFocusTargetGlobal;
-	// don't enforce zoom constraints as this is the only way for users to get past them easily
-	updateFocusOffset();
-	// NOTE: panning movements expect the camera to move exactly with the focus target, not animated behind -Nyx
-	mCameraSmoothingLastPositionGlobal = calcCameraPositionTargetGlobal();
-}
-
-//-----------------------------------------------------------------------------
-// cameraPanLeft()
-//-----------------------------------------------------------------------------
-void LLAgentCamera::cameraPanLeft(F32 meters)
-{
-	LLVector3d left_axis;
-	left_axis.setVec(LLViewerCamera::getInstance()->getLeftAxis());
-
-	mPanFocusDiff += meters * left_axis;
-
-	mFocusTargetGlobal += meters * left_axis;
-	mFocusGlobal = mFocusTargetGlobal;
-
-	// disable smoothing for camera pan, which causes some residents unhappiness
-	mCameraSmoothingStop = true;
-	
-	cameraZoomIn(1.f);
-	updateFocusOffset();
-	// NOTE: panning movements expect the camera to move exactly with the focus target, not animated behind - Nyx
-	mCameraSmoothingLastPositionGlobal = calcCameraPositionTargetGlobal();
-}
-
-//-----------------------------------------------------------------------------
-// cameraPanUp()
-//-----------------------------------------------------------------------------
-void LLAgentCamera::cameraPanUp(F32 meters)
-{
-	LLVector3d up_axis;
-	up_axis.setVec(LLViewerCamera::getInstance()->getUpAxis());
-
-	mPanFocusDiff += meters * up_axis;
-
-	mFocusTargetGlobal += meters * up_axis;
-	mFocusGlobal = mFocusTargetGlobal;
-
-	// disable smoothing for camera pan, which causes some residents unhappiness
-	mCameraSmoothingStop = true;
-
-	cameraZoomIn(1.f);
-	updateFocusOffset();
-	// NOTE: panning movements expect the camera to move exactly with the focus target, not animated behind -Nyx
-	mCameraSmoothingLastPositionGlobal = calcCameraPositionTargetGlobal();
-}
-
-void LLAgentCamera::resetCameraPan()
-{
-	mFocusTargetGlobal -= mPanFocusDiff;
-
-	mFocusGlobal = mFocusTargetGlobal;
-	mCameraSmoothingStop = true;
-
-	cameraZoomIn(1.f);
-	updateFocusOffset();
-
-	mCameraSmoothingLastPositionGlobal = calcCameraPositionTargetGlobal();
-
-	resetPanDiff();
-}
-
-void LLAgentCamera::resetPanDiff()
-{
-	mPanFocusDiff.clear();
-}
-
-//-----------------------------------------------------------------------------
-// updateLookAt()
-//-----------------------------------------------------------------------------
-void LLAgentCamera::updateLookAt(const S32 mouse_x, const S32 mouse_y)
-{
-	static LLVector3 last_at_axis;
-
-	if (!isAgentAvatarValid()) return;
-
-	LLQuaternion av_inv_rot = ~gAgentAvatarp->mRoot->getWorldRotation();
-	LLVector3 root_at = LLVector3::x_axis * gAgentAvatarp->mRoot->getWorldRotation();
-
-	if 	(LLTrace::get_frame_recording().getLastRecording().getLastValue(*gViewerWindow->getMouseVelocityStat()) < 0.01f
-		&& (root_at * last_at_axis > 0.95f))
-	{
-		LLVector3 vel = gAgentAvatarp->getVelocity();
-		if (vel.magVecSquared() > 4.f)
-		{
-			setLookAt(LOOKAT_TARGET_IDLE, gAgentAvatarp, vel * av_inv_rot);
-		}
-		else
-		{
-			// *FIX: rotate mframeagent by sit object's rotation?
-			LLQuaternion look_rotation = gAgentAvatarp->isSitting() ? gAgentAvatarp->getRenderRotation() : gAgent.getFrameAgent().getQuaternion(); // use camera's current rotation
-			LLVector3 look_offset = LLVector3(2.f, 0.f, 0.f) * look_rotation * av_inv_rot;
-			setLookAt(LOOKAT_TARGET_IDLE, gAgentAvatarp, look_offset);
-		}
-		last_at_axis = root_at;
-		return;
-	}
-
-	last_at_axis = root_at;
-	
-	if (CAMERA_MODE_CUSTOMIZE_AVATAR == getCameraMode())
-	{
-		setLookAt(LOOKAT_TARGET_NONE, gAgentAvatarp, LLVector3(-2.f, 0.f, 0.f));	
-	}
-	else
-	{
-		// Move head based on cursor position
-		ELookAtType lookAtType = LOOKAT_TARGET_NONE;
-		LLVector3 headLookAxis;
-		LLCoordFrame frameCamera = *((LLCoordFrame*)LLViewerCamera::getInstance());
-
-		if (cameraMouselook())
-		{
-			lookAtType = LOOKAT_TARGET_MOUSELOOK;
-		}
-		else if (cameraThirdPerson())
-		{
-			// range from -.5 to .5
-			F32 x_from_center = 
-				((F32) mouse_x / (F32) gViewerWindow->getWorldViewWidthScaled() ) - 0.5f;
-			F32 y_from_center = 
-				((F32) mouse_y / (F32) gViewerWindow->getWorldViewHeightScaled() ) - 0.5f;
-
-			frameCamera.yaw( - x_from_center * gSavedSettings.getF32("YawFromMousePosition") * DEG_TO_RAD);
-			frameCamera.pitch( - y_from_center * gSavedSettings.getF32("PitchFromMousePosition") * DEG_TO_RAD);
-			lookAtType = LOOKAT_TARGET_FREELOOK;
-		}
-
-		headLookAxis = frameCamera.getAtAxis();
-		// RN: we use world-space offset for mouselook and freelook
-		//headLookAxis = headLookAxis * av_inv_rot;
-		setLookAt(lookAtType, gAgentAvatarp, headLookAxis);
-	}
-}
-
-static LLTrace::BlockTimerStatHandle FTM_UPDATE_CAMERA("Camera");
-
-extern bool gCubeSnapshot;
-
-//-----------------------------------------------------------------------------
-// updateCamera()
-//-----------------------------------------------------------------------------
-void LLAgentCamera::updateCamera()
-{
-	LL_RECORD_BLOCK_TIME(FTM_UPDATE_CAMERA);
-    if (gCubeSnapshot)
-    {
-        return;
-    }
-
-	// - changed camera_skyward to the new global "mCameraUpVector"
-	mCameraUpVector = LLVector3::z_axis;
-	//LLVector3	camera_skyward(0.f, 0.f, 1.f);
-
-	U32 camera_mode = mCameraAnimating ? mLastCameraMode : mCameraMode;
-
-	validateFocusObject();
-
-	if (isAgentAvatarValid() && 
-		gAgentAvatarp->isSitting() &&
-		camera_mode == CAMERA_MODE_MOUSELOOK)
-	{
-		//changed camera_skyward to the new global "mCameraUpVector"
-		mCameraUpVector = mCameraUpVector * gAgentAvatarp->getRenderRotation();
-	}
-
-	if (cameraThirdPerson() && (mFocusOnAvatar || mAllowChangeToFollow) && LLFollowCamMgr::getInstance()->getActiveFollowCamParams())
-	{
-		mAllowChangeToFollow = false;
-		mFocusOnAvatar = true;
-		changeCameraToFollow();
-	}
-
-	//NOTE - this needs to be integrated into a general upVector system here within llAgent. 
-	if ( camera_mode == CAMERA_MODE_FOLLOW && mFocusOnAvatar )
-	{
-		mCameraUpVector = mFollowCam.getUpVector();
-	}
-
-	if (mSitCameraEnabled)
-	{
-		if (mSitCameraReferenceObject->isDead())
-		{
-			setSitCamera(LLUUID::null);
-		}
-	}
-
-	// Update UI with our camera inputs
-	LLFloaterCamera* camera_floater = LLFloaterReg::findTypedInstance<LLFloaterCamera>("camera");
-	if (camera_floater)
-	{
-		camera_floater->mRotate->setToggleState(gAgentCamera.getOrbitRightKey() > 0.f,	// left
-												gAgentCamera.getOrbitUpKey() > 0.f,		// top
-												gAgentCamera.getOrbitLeftKey() > 0.f,	// right
-												gAgentCamera.getOrbitDownKey() > 0.f);	// bottom
-		
-		camera_floater->mTrack->setToggleState(gAgentCamera.getPanLeftKey() > 0.f,		// left
-											   gAgentCamera.getPanUpKey() > 0.f,			// top
-											   gAgentCamera.getPanRightKey() > 0.f,		// right
-											   gAgentCamera.getPanDownKey() > 0.f);		// bottom
-	}
-
-	// Handle camera movement based on keyboard.
-	const F32 ORBIT_OVER_RATE = 90.f * DEG_TO_RAD;			// radians per second
-	const F32 ORBIT_AROUND_RATE = 90.f * DEG_TO_RAD;		// radians per second
-	const F32 PAN_RATE = 5.f;								// meters per second
-
-	if (gAgentCamera.getOrbitUpKey() || gAgentCamera.getOrbitDownKey())
-	{
-		F32 input_rate = gAgentCamera.getOrbitUpKey() - gAgentCamera.getOrbitDownKey();
-		cameraOrbitOver( input_rate * ORBIT_OVER_RATE / gFPSClamped );
-	}
-
-	if (gAgentCamera.getOrbitLeftKey() || gAgentCamera.getOrbitRightKey())
-	{
-		F32 input_rate = gAgentCamera.getOrbitLeftKey() - gAgentCamera.getOrbitRightKey();
-		cameraOrbitAround(input_rate * ORBIT_AROUND_RATE / gFPSClamped);
-	}
-
-	if (gAgentCamera.getOrbitInKey() || gAgentCamera.getOrbitOutKey())
-	{
-		F32 input_rate = gAgentCamera.getOrbitInKey() - gAgentCamera.getOrbitOutKey();
-		
-		LLVector3d to_focus = gAgent.getPosGlobalFromAgent(LLViewerCamera::getInstance()->getOrigin()) - calcFocusPositionTargetGlobal();
-		F32 distance_to_focus = (F32)to_focus.magVec();
-		// Move at distance (in meters) meters per second
-		cameraOrbitIn( input_rate * distance_to_focus / gFPSClamped );
-	}
-
-	if (gAgentCamera.getPanInKey() || gAgentCamera.getPanOutKey())
-	{
-		F32 input_rate = gAgentCamera.getPanInKey() - gAgentCamera.getPanOutKey();
-		cameraPanIn(input_rate * PAN_RATE / gFPSClamped);
-	}
-
-	if (gAgentCamera.getPanRightKey() || gAgentCamera.getPanLeftKey())
-	{
-		F32 input_rate = gAgentCamera.getPanRightKey() - gAgentCamera.getPanLeftKey();
-		cameraPanLeft(input_rate * -PAN_RATE / gFPSClamped );
-	}
-
-	if (gAgentCamera.getPanUpKey() || gAgentCamera.getPanDownKey())
-	{
-		F32 input_rate = gAgentCamera.getPanUpKey() - gAgentCamera.getPanDownKey();
-		cameraPanUp(input_rate * PAN_RATE / gFPSClamped );
-	}
-
-	// Clear camera keyboard keys.
-	gAgentCamera.clearOrbitKeys();
-	gAgentCamera.clearPanKeys();
-
-	// lerp camera focus offset
-	mCameraFocusOffset = lerp(mCameraFocusOffset, mCameraFocusOffsetTarget, LLSmoothInterpolation::getInterpolant(CAMERA_FOCUS_HALF_LIFE));
-
-	if ( mCameraMode == CAMERA_MODE_FOLLOW )
-	{
-		if (isAgentAvatarValid())
-		{
-			//--------------------------------------------------------------------------------
-			// this is where the avatar's position and rotation are given to followCam, and 
-			// where it is updated. All three of its attributes are updated: (1) position, 
-			// (2) focus, and (3) upvector. They can then be queried elsewhere in llAgent.
-			//--------------------------------------------------------------------------------
-			// *TODO: use combined rotation of frameagent and sit object
-			LLQuaternion avatarRotationForFollowCam = gAgentAvatarp->isSitting() ? gAgentAvatarp->getRenderRotation() : gAgent.getFrameAgent().getQuaternion();
-
-			LLFollowCamParams* current_cam = LLFollowCamMgr::getInstance()->getActiveFollowCamParams();
-			if (current_cam)
-			{
-				mFollowCam.copyParams(*current_cam);
-				mFollowCam.setSubjectPositionAndRotation( gAgentAvatarp->getRenderPosition(), avatarRotationForFollowCam );
-				mFollowCam.update();
-				LLViewerJoystick::getInstance()->setCameraNeedsUpdate(true);
-			}
-			else
-			{
-				changeCameraToThirdPerson(true);
-			}
-		}
-	}
-
-	bool hit_limit;
-	LLVector3d camera_pos_global;
-	LLVector3d camera_target_global = calcCameraPositionTargetGlobal(&hit_limit);
-	mCameraVirtualPositionAgent = gAgent.getPosAgentFromGlobal(camera_target_global);
-	LLVector3d focus_target_global = calcFocusPositionTargetGlobal();
-
-	// perform field of view correction
-	mCameraFOVZoomFactor = calcCameraFOVZoomFactor();
-	camera_target_global = focus_target_global + (camera_target_global - focus_target_global) * (1.f + mCameraFOVZoomFactor);
-
-	gAgent.setShowAvatar(true); // can see avatar by default
-
-	// Adjust position for animation
-	if (mCameraAnimating)
-	{
-		F32 time = mAnimationTimer.getElapsedTimeF32();
-
-		// yet another instance of critically damped motion, hooray!
-		// F32 fraction_of_animation = 1.f - pow(2.f, -time / CAMERA_ZOOM_HALF_LIFE);
-
-		// linear interpolation
-		F32 fraction_of_animation = time / mAnimationDuration;
-
-		bool isfirstPerson = mCameraMode == CAMERA_MODE_MOUSELOOK;
-		bool wasfirstPerson = mLastCameraMode == CAMERA_MODE_MOUSELOOK;
-		F32 fraction_animation_to_skip;
-
-		if (mAnimationCameraStartGlobal == camera_target_global)
-		{
-			fraction_animation_to_skip = 0.f;
-		}
-		else
-		{
-			LLVector3d cam_delta = mAnimationCameraStartGlobal - camera_target_global;
-			fraction_animation_to_skip = HEAD_BUFFER_SIZE / (F32)cam_delta.magVec();
-		}
-		F32 animation_start_fraction = (wasfirstPerson) ? fraction_animation_to_skip : 0.f;
-		F32 animation_finish_fraction =  (isfirstPerson) ? (1.f - fraction_animation_to_skip) : 1.f;
-	
-		if (fraction_of_animation < animation_finish_fraction)
-		{
-			if (fraction_of_animation < animation_start_fraction || fraction_of_animation > animation_finish_fraction )
-			{
-				gAgent.setShowAvatar(false);
-			}
-
-			// ...adjust position for animation
-			F32 smooth_fraction_of_animation = llsmoothstep(0.0f, 1.0f, fraction_of_animation);
-			camera_pos_global = lerp(mAnimationCameraStartGlobal, camera_target_global, smooth_fraction_of_animation);
-			mFocusGlobal = lerp(mAnimationFocusStartGlobal, focus_target_global, smooth_fraction_of_animation);
-		}
-		else
-		{
-			// ...animation complete
-			mCameraAnimating = false;
-
-			camera_pos_global = camera_target_global;
-			mFocusGlobal = focus_target_global;
-
-			gAgent.endAnimationUpdateUI();
-			gAgent.setShowAvatar(true);
-		}
-
-		if (isAgentAvatarValid() && (mCameraMode != CAMERA_MODE_MOUSELOOK))
-		{
-			gAgentAvatarp->updateAttachmentVisibility(mCameraMode);
-		}
-	}
-	else 
-	{
-		camera_pos_global = camera_target_global;
-		mFocusGlobal = focus_target_global;
-		gAgent.setShowAvatar(true);
-	}
-
-	// smoothing
-	if (true)
-	{
-		LLVector3d agent_pos = gAgent.getPositionGlobal();
-		LLVector3d camera_pos_agent = camera_pos_global - agent_pos;
-		// Sitting on what you're manipulating can cause camera jitter with smoothing. 
-		// This turns off smoothing while editing. -MG
-		bool in_build_mode = LLToolMgr::getInstance()->inBuildMode();
-		mCameraSmoothingStop = mCameraSmoothingStop || in_build_mode;
-		
-		if (cameraThirdPerson() && !mCameraSmoothingStop)
-		{
-			const F32 SMOOTHING_HALF_LIFE = 0.02f;
-			
-			F32 smoothing = LLSmoothInterpolation::getInterpolant(gSavedSettings.getF32("CameraPositionSmoothing") * SMOOTHING_HALF_LIFE, false);
-					
-			if (mFocusOnAvatar && !mFocusObject) // we differentiate on avatar mode 
-			{
-				// for avatar-relative focus, we smooth in avatar space -
-				// the avatar moves too jerkily w/r/t global space to smooth there.
-
-				LLVector3d delta = camera_pos_agent - mCameraSmoothingLastPositionAgent;
-				if (delta.magVec() < MAX_CAMERA_SMOOTH_DISTANCE)  // only smooth over short distances please
-				{
-					camera_pos_agent = lerp(mCameraSmoothingLastPositionAgent, camera_pos_agent, smoothing);
-					camera_pos_global = camera_pos_agent + agent_pos;
-				}
-			}
-			else
-			{
-				LLVector3d delta = camera_pos_global - mCameraSmoothingLastPositionGlobal;
-				if (delta.magVec() < MAX_CAMERA_SMOOTH_DISTANCE) // only smooth over short distances please
-				{
-					camera_pos_global = lerp(mCameraSmoothingLastPositionGlobal, camera_pos_global, smoothing);
-				}
-			}
-		}
-								 
-		mCameraSmoothingLastPositionGlobal = camera_pos_global;
-		mCameraSmoothingLastPositionAgent = camera_pos_agent;
-		mCameraSmoothingStop = false;
-	}
-
-	
-	mCameraCurrentFOVZoomFactor = lerp(mCameraCurrentFOVZoomFactor, mCameraFOVZoomFactor, LLSmoothInterpolation::getInterpolant(FOV_ZOOM_HALF_LIFE));
-
-//	LL_INFOS() << "Current FOV Zoom: " << mCameraCurrentFOVZoomFactor << " Target FOV Zoom: " << mCameraFOVZoomFactor << " Object penetration: " << mFocusObjectDist << LL_ENDL;
-
-	LLVector3 focus_agent = gAgent.getPosAgentFromGlobal(mFocusGlobal);
-	
-	mCameraPositionAgent = gAgent.getPosAgentFromGlobal(camera_pos_global);
-
-	// Move the camera
-
-	LLViewerCamera::getInstance()->updateCameraLocation(mCameraPositionAgent, mCameraUpVector, focus_agent);
-	//LLViewerCamera::getInstance()->updateCameraLocation(mCameraPositionAgent, camera_skyward, focus_agent);
-	
-	// Change FOV
-	LLViewerCamera::getInstance()->setView(LLViewerCamera::getInstance()->getDefaultFOV() / (1.f + mCameraCurrentFOVZoomFactor));
-
-	// follow camera when in customize mode
-	if (cameraCustomizeAvatar())	
-	{
-		setLookAt(LOOKAT_TARGET_FOCUS, NULL, mCameraPositionAgent);
-	}
-
-	// update the travel distance stat
-	// this isn't directly related to the camera
-	// but this seemed like the best place to do this
-	LLVector3d global_pos = gAgent.getPositionGlobal(); 
-	if (!gAgent.getLastPositionGlobal().isExactlyZero())
-	{
-		LLVector3d delta = global_pos - gAgent.getLastPositionGlobal();
-		gAgent.setDistanceTraveled(gAgent.getDistanceTraveled() + delta.magVec());
-	}
-	gAgent.setLastPositionGlobal(global_pos);
-	
-	if (LLVOAvatar::sVisibleInFirstPerson && isAgentAvatarValid() && !gAgentAvatarp->isSitting() && cameraMouselook())
-	{
-		LLVector3 head_pos = gAgentAvatarp->mHeadp->getWorldPosition() + 
-			LLVector3(0.08f, 0.f, 0.05f) * gAgentAvatarp->mHeadp->getWorldRotation() + 
-			LLVector3(0.1f, 0.f, 0.f) * gAgentAvatarp->mPelvisp->getWorldRotation();
-		LLVector3 diff = mCameraPositionAgent - head_pos;
-		diff = diff * ~gAgentAvatarp->mRoot->getWorldRotation();
-
-		LLJoint* torso_joint = gAgentAvatarp->mTorsop;
-		LLJoint* chest_joint = gAgentAvatarp->mChestp;
-		LLVector3 torso_scale = torso_joint->getScale();
-		LLVector3 chest_scale = chest_joint->getScale();
-
-		// shorten avatar skeleton to avoid foot interpenetration
-		if (!gAgentAvatarp->mInAir)
-		{
-			LLVector3 chest_offset = LLVector3(0.f, 0.f, chest_joint->getPosition().mV[VZ]) * torso_joint->getWorldRotation();
-			F32 z_compensate = llclamp(-diff.mV[VZ], -0.2f, 1.f);
-			F32 scale_factor = llclamp(1.f - ((z_compensate * 0.5f) / chest_offset.mV[VZ]), 0.5f, 1.2f);
-			torso_joint->setScale(LLVector3(1.f, 1.f, scale_factor));
-
-			LLJoint* neck_joint = gAgentAvatarp->mNeckp;
-			LLVector3 neck_offset = LLVector3(0.f, 0.f, neck_joint->getPosition().mV[VZ]) * chest_joint->getWorldRotation();
-			scale_factor = llclamp(1.f - ((z_compensate * 0.5f) / neck_offset.mV[VZ]), 0.5f, 1.2f);
-			chest_joint->setScale(LLVector3(1.f, 1.f, scale_factor));
-			diff.mV[VZ] = 0.f;
-		}
-
-		// SL-315
-		gAgentAvatarp->mPelvisp->setPosition(gAgentAvatarp->mPelvisp->getPosition() + diff);
-
-		gAgentAvatarp->mRoot->updateWorldMatrixChildren();
-
-		for (LLVOAvatar::attachment_map_t::iterator iter = gAgentAvatarp->mAttachmentPoints.begin(); 
-			 iter != gAgentAvatarp->mAttachmentPoints.end(); )
-		{
-			LLVOAvatar::attachment_map_t::iterator curiter = iter++;
-			LLViewerJointAttachment* attachment = curiter->second;
-			for (LLViewerJointAttachment::attachedobjs_vec_t::iterator attachment_iter = attachment->mAttachedObjects.begin();
-				 attachment_iter != attachment->mAttachedObjects.end();
-				 ++attachment_iter)
-			{
-				LLViewerObject *attached_object = attachment_iter->get();
-				if (attached_object && !attached_object->isDead() && attached_object->mDrawable.notNull())
-				{
-					// clear any existing "early" movements of attachment
-					attached_object->mDrawable->clearState(LLDrawable::EARLY_MOVE);
-					gPipeline.updateMoveNormalAsync(attached_object->mDrawable);
-					attached_object->updateText();
-				}
-			}
-		}
-
-		torso_joint->setScale(torso_scale);
-		chest_joint->setScale(chest_scale);
-	}
-}
-
-void LLAgentCamera::updateLastCamera()
-{
-	mLastCameraMode = mCameraMode;
-}
-
-void LLAgentCamera::updateFocusOffset()
-{
-	validateFocusObject();
-	if (mFocusObject.notNull())
-	{
-		LLVector3d obj_pos = gAgent.getPosGlobalFromAgent(mFocusObject->getRenderPosition());
-		mFocusObjectOffset.setVec(mFocusTargetGlobal - obj_pos);
-	}
-}
-
-void LLAgentCamera::validateFocusObject()
-{
-	if (mFocusObject.notNull() && 
-		mFocusObject->isDead())
-	{
-		mFocusObjectOffset.clearVec();
-		clearFocusObject();
-		mCameraFOVZoomFactor = 0.f;
-	}
-}
-
-//-----------------------------------------------------------------------------
-// calcFocusPositionTargetGlobal()
-//-----------------------------------------------------------------------------
-LLVector3d LLAgentCamera::calcFocusPositionTargetGlobal()
-{
-	if (mFocusObject.notNull() && mFocusObject->isDead())
-	{
-		clearFocusObject();
-	}
-
-	if (mCameraMode == CAMERA_MODE_FOLLOW && mFocusOnAvatar)
-	{
-		mFocusTargetGlobal = gAgent.getPosGlobalFromAgent(mFollowCam.getSimulatedFocus());
-		return mFocusTargetGlobal;
-	}
-	else if (mCameraMode == CAMERA_MODE_MOUSELOOK)
-	{
-		LLVector3d at_axis(1.0, 0.0, 0.0);
-		LLQuaternion agent_rot = gAgent.getFrameAgent().getQuaternion();
-		if (isAgentAvatarValid() && gAgentAvatarp->getParent())
-		{
-			LLViewerObject* root_object = (LLViewerObject*)gAgentAvatarp->getRoot();
-			if (!root_object->flagCameraDecoupled())
-			{
-				agent_rot *= ((LLViewerObject*)(gAgentAvatarp->getParent()))->getRenderRotation();
-			}
-		}
-		at_axis = at_axis * agent_rot;
-		mFocusTargetGlobal = calcCameraPositionTargetGlobal() + at_axis;
-		return mFocusTargetGlobal;
-	}
-	else if (mCameraMode == CAMERA_MODE_CUSTOMIZE_AVATAR)
-	{
-		if (mFocusOnAvatar)
-		{
-			LLVector3 focus_target = isAgentAvatarValid()
-				? gAgentAvatarp->mHeadp->getWorldPosition()
-				: gAgent.getPositionAgent();
-			LLVector3d focus_target_global = gAgent.getPosGlobalFromAgent(focus_target);
-			mFocusTargetGlobal = focus_target_global;
-		}
-		return mFocusTargetGlobal;
-	}
-	else if (!mFocusOnAvatar)
-	{
-		if (mFocusObject.notNull() && !mFocusObject->isDead() && mFocusObject->mDrawable.notNull())
-		{
-			LLDrawable* drawablep = mFocusObject->mDrawable;
-			
-			if (mTrackFocusObject &&
-				drawablep && 
-				drawablep->isActive())
-			{
-				if (!mFocusObject->isAvatar())
-				{
-					if (mFocusObject->isSelected())
-					{
-						gPipeline.updateMoveNormalAsync(drawablep);
-					}
-					else
-					{
-						if (drawablep->isState(LLDrawable::MOVE_UNDAMPED))
-						{
-							gPipeline.updateMoveNormalAsync(drawablep);
-						}
-						else
-						{
-							gPipeline.updateMoveDampedAsync(drawablep);
-						}
-					}
-				}
-			}
-			// if not tracking object, update offset based on new object position
-			else
-			{
-				updateFocusOffset();
-			}
-			LLVector3 focus_agent = mFocusObject->getRenderPosition() + mFocusObjectOffset;
-			mFocusTargetGlobal.setVec(gAgent.getPosGlobalFromAgent(focus_agent));
-		}
-		return mFocusTargetGlobal;
-	}
-	else if (mSitCameraEnabled && isAgentAvatarValid() && gAgentAvatarp->isSitting() && mSitCameraReferenceObject.notNull())
-	{
-		// sit camera
-		LLVector3 object_pos = mSitCameraReferenceObject->getRenderPosition();
-		LLQuaternion object_rot = mSitCameraReferenceObject->getRenderRotation();
-
-		LLVector3 target_pos = object_pos + (mSitCameraFocus * object_rot);
-		return gAgent.getPosGlobalFromAgent(target_pos);
-	}
-	else
-	{
-		return gAgent.getPositionGlobal() + calcThirdPersonFocusOffset();
-	}
-}
-
-LLVector3d LLAgentCamera::calcThirdPersonFocusOffset()
-{
-	// ...offset from avatar
-	LLVector3d focus_offset;
-	LLQuaternion agent_rot = gAgent.getFrameAgent().getQuaternion();
-	if (isAgentAvatarValid() && gAgentAvatarp->getParent())
-	{
-		agent_rot *= ((LLViewerObject*)(gAgentAvatarp->getParent()))->getRenderRotation();
-	}
-
-    static LLCachedControl<LLVector3d> focus_offset_initial(gSavedSettings, "FocusOffsetRearView", LLVector3d());
-	return focus_offset_initial * agent_rot;
-}
-
-void LLAgentCamera::setupSitCamera()
-{
-	// agent frame entering this function is in world coordinates
-	if (isAgentAvatarValid() && gAgentAvatarp->getParent())
-	{
-		LLQuaternion parent_rot = ((LLViewerObject*)gAgentAvatarp->getParent())->getRenderRotation();
-		// slam agent coordinate frame to proper parent local version
-		LLVector3 at_axis = gAgent.getFrameAgent().getAtAxis();
-		at_axis.mV[VZ] = 0.f;
-		at_axis.normalize();
-		gAgent.resetAxes(at_axis * ~parent_rot);
-	}
-}
-
-//-----------------------------------------------------------------------------
-// getCameraPositionAgent()
-//-----------------------------------------------------------------------------
-const LLVector3 &LLAgentCamera::getCameraPositionAgent() const
-{
-	return LLViewerCamera::getInstance()->getOrigin();
-}
-
-//-----------------------------------------------------------------------------
-// getCameraPositionGlobal()
-//-----------------------------------------------------------------------------
-LLVector3d LLAgentCamera::getCameraPositionGlobal() const
-{
-	return gAgent.getPosGlobalFromAgent(LLViewerCamera::getInstance()->getOrigin());
-}
-
-//-----------------------------------------------------------------------------
-// calcCameraFOVZoomFactor()
-//-----------------------------------------------------------------------------
-F32	LLAgentCamera::calcCameraFOVZoomFactor()
-{
-	LLVector3 camera_offset_dir;
-	camera_offset_dir.setVec(mCameraFocusOffset);
-
-	if (mCameraMode == CAMERA_MODE_MOUSELOOK)
-	{
-		return 0.f;
-	}
-	else if (mFocusObject.notNull() && !mFocusObject->isAvatar() && !mFocusOnAvatar)
-	{
-		// don't FOV zoom on mostly transparent objects
-		F32 obj_min_dist = 0.f;
-		calcCameraMinDistance(obj_min_dist);
-		F32 current_distance = llmax(0.001f, camera_offset_dir.magVec());
-
-		mFocusObjectDist = obj_min_dist - current_distance;
-
-		F32 new_fov_zoom = llclamp(mFocusObjectDist / current_distance, 0.f, 1000.f);
-		return new_fov_zoom;
-	}
-	else // focusing on land or avatar
-	{
-		// keep old field of view until user changes focus explicitly
-		return mCameraFOVZoomFactor;
-		//return 0.f;
-	}
-}
-
-//-----------------------------------------------------------------------------
-// calcCameraPositionTargetGlobal()
-//-----------------------------------------------------------------------------
-LLVector3d LLAgentCamera::calcCameraPositionTargetGlobal(bool *hit_limit)
-{
-	// Compute base camera position and look-at points.
-	F32			camera_land_height;
-	LLVector3d	frame_center_global = !isAgentAvatarValid() ? 
-		gAgent.getPositionGlobal() :
-		gAgent.getPosGlobalFromAgent(getAvatarRootPosition());
-	
-	bool		isConstrained = false;
-	LLVector3d	head_offset;
-	head_offset.setVec(mThirdPersonHeadOffset);
-
-	LLVector3d camera_position_global;
-
-	if (mCameraMode == CAMERA_MODE_FOLLOW && mFocusOnAvatar)
-	{
-		camera_position_global = gAgent.getPosGlobalFromAgent(mFollowCam.getSimulatedPosition());
-	}
-	else if (mCameraMode == CAMERA_MODE_MOUSELOOK)
-	{
-		if (!isAgentAvatarValid() || gAgentAvatarp->mDrawable.isNull())
-		{
-			LL_WARNS() << "Null avatar drawable!" << LL_ENDL;
-			return LLVector3d::zero;
-		}
-
-		head_offset.clearVec();
-		F32 fixup;
-        if (gAgentAvatarp->hasPelvisFixup(fixup) && !gAgentAvatarp->isSitting())
-		{
-			head_offset[VZ] -= fixup;
-		}
-		if (gAgentAvatarp->isSitting())
-		{
-			head_offset.mdV[VZ] += 0.1;
-		}
-
-		if (gAgentAvatarp->isSitting() && gAgentAvatarp->getParent())
-		{
-			gAgentAvatarp->updateHeadOffset();
-			head_offset.mdV[VX] += gAgentAvatarp->mHeadOffset.mV[VX];
-			head_offset.mdV[VY] += gAgentAvatarp->mHeadOffset.mV[VY];
-			head_offset.mdV[VZ] += gAgentAvatarp->mHeadOffset.mV[VZ];
-			const LLMatrix4& mat = ((LLViewerObject*) gAgentAvatarp->getParent())->getRenderMatrix();
-			camera_position_global = gAgent.getPosGlobalFromAgent
-								((gAgentAvatarp->getPosition()+
-								 LLVector3(head_offset)*gAgentAvatarp->getRotation()) * mat);
-		}
-		else
-		{
-			head_offset.mdV[VZ] += gAgentAvatarp->mHeadOffset.mV[VZ];
-			camera_position_global = gAgent.getPosGlobalFromAgent(gAgentAvatarp->getRenderPosition());//frame_center_global;
-			head_offset = head_offset * gAgentAvatarp->getRenderRotation();
-			camera_position_global = camera_position_global + head_offset;
-		}
-	}
-	else if (mCameraMode == CAMERA_MODE_THIRD_PERSON && mFocusOnAvatar)
-	{
-		LLVector3 local_camera_offset;
-		F32 camera_distance = 0.f;
-
-		if (mSitCameraEnabled 
-			&& isAgentAvatarValid() 
-			&& gAgentAvatarp->isSitting() 
-			&& mSitCameraReferenceObject.notNull())
-		{
-			// sit camera
-			LLVector3 object_pos = mSitCameraReferenceObject->getRenderPosition();
-			LLQuaternion object_rot = mSitCameraReferenceObject->getRenderRotation();
-
-			LLVector3 target_pos = object_pos + (mSitCameraPos * object_rot);
-
-			camera_position_global = gAgent.getPosGlobalFromAgent(target_pos);
-		}
-		else
-		{
-            static LLCachedControl<F32> camera_offset_scale(gSavedSettings, "CameraOffsetScale");
-            local_camera_offset = mCameraZoomFraction * getCameraOffsetInitial() * camera_offset_scale;
-
-			// are we sitting down?
-			if (isAgentAvatarValid() && gAgentAvatarp->getParent())
-			{
-				LLQuaternion parent_rot = ((LLViewerObject*)gAgentAvatarp->getParent())->getRenderRotation();
-				// slam agent coordinate frame to proper parent local version
-				LLVector3 at_axis = gAgent.getFrameAgent().getAtAxis() * parent_rot;
-				at_axis.mV[VZ] = 0.f;
-				at_axis.normalize();
-				gAgent.resetAxes(at_axis * ~parent_rot);
-				
-				local_camera_offset = local_camera_offset * gAgent.getFrameAgent().getQuaternion() * parent_rot;
-			}
-			else
-			{
-				local_camera_offset = gAgent.getFrameAgent().rotateToAbsolute( local_camera_offset );
-			}
-
-			if (!isDisableCameraConstraints() && !mCameraCollidePlane.isExactlyZero() &&
-				(!isAgentAvatarValid() || !gAgentAvatarp->isSitting()))
-			{
-				LLVector3 plane_normal;
-				plane_normal.setVec(mCameraCollidePlane.mV);
-
-				F32 offset_dot_norm = local_camera_offset * plane_normal;
-				if (llabs(offset_dot_norm) < 0.001f)
-				{
-					offset_dot_norm = 0.001f;
-				}
-				
-				camera_distance = local_camera_offset.normalize();
-
-				F32 pos_dot_norm = gAgent.getPosAgentFromGlobal(frame_center_global + head_offset) * plane_normal;
-				
-				// if agent is outside the colliding half-plane
-				if (pos_dot_norm > mCameraCollidePlane.mV[VW])
-				{
-					// check to see if camera is on the opposite side (inside) the half-plane
-					if (offset_dot_norm + pos_dot_norm < mCameraCollidePlane.mV[VW])
-					{
-						// diminish offset by factor to push it back outside the half-plane
-						camera_distance *= (pos_dot_norm - mCameraCollidePlane.mV[VW] - CAMERA_COLLIDE_EPSILON) / -offset_dot_norm;
-					}
-				}
-				else
-				{
-					if (offset_dot_norm + pos_dot_norm > mCameraCollidePlane.mV[VW])
-					{
-						camera_distance *= (mCameraCollidePlane.mV[VW] - pos_dot_norm - CAMERA_COLLIDE_EPSILON) / offset_dot_norm;
-					}
-				}
-			}
-			else
-			{
-				camera_distance = local_camera_offset.normalize();
-			}
-
-			mTargetCameraDistance = llmax(camera_distance, MIN_CAMERA_DISTANCE);
-
-			if (mTargetCameraDistance != mCurrentCameraDistance)
-			{
-				F32 camera_lerp_amt = LLSmoothInterpolation::getInterpolant(CAMERA_ZOOM_HALF_LIFE);
-
-				mCurrentCameraDistance = lerp(mCurrentCameraDistance, mTargetCameraDistance, camera_lerp_amt);
-			}
-
-			// Make the camera distance current
-			local_camera_offset *= mCurrentCameraDistance;
-
-			// set the global camera position
-			LLVector3d camera_offset;
-			
-			camera_offset.setVec( local_camera_offset );
-			camera_position_global = frame_center_global + head_offset + camera_offset;
-
-			if (isAgentAvatarValid())
-			{
-				LLVector3d camera_lag_d;
-				F32 lag_interp = LLSmoothInterpolation::getInterpolant(CAMERA_LAG_HALF_LIFE);
-				LLVector3 target_lag;
-				LLVector3 vel = gAgent.getVelocity();
-
-				// lag by appropriate amount for flying
-				F32 time_in_air = gAgentAvatarp->mTimeInAir.getElapsedTimeF32();
-				if(!mCameraAnimating && gAgentAvatarp->mInAir && time_in_air > GROUND_TO_AIR_CAMERA_TRANSITION_START_TIME)
-				{
-					LLVector3 frame_at_axis = gAgent.getFrameAgent().getAtAxis();
-					frame_at_axis -= projected_vec(frame_at_axis, gAgent.getReferenceUpVector());
-					frame_at_axis.normalize();
-
-					//transition smoothly in air mode, to avoid camera pop
-					F32 u = (time_in_air - GROUND_TO_AIR_CAMERA_TRANSITION_START_TIME) / GROUND_TO_AIR_CAMERA_TRANSITION_TIME;
-					u = llclamp(u, 0.f, 1.f);
-
-					lag_interp *= u;
-
-					if (gViewerWindow->getLeftMouseDown() && gViewerWindow->getLastPick().mObjectID == gAgentAvatarp->getID())
-					{
-						// disable camera lag when using mouse-directed steering
-						target_lag.clearVec();
-					}
-					else
-					{
-						target_lag = vel * gSavedSettings.getF32("DynamicCameraStrength") / 30.f;
-					}
-
-					mCameraLag = lerp(mCameraLag, target_lag, lag_interp);
-
-					F32 lag_dist = mCameraLag.magVec();
-					if (lag_dist > MAX_CAMERA_LAG)
-					{
-						mCameraLag = mCameraLag * MAX_CAMERA_LAG / lag_dist;
-					}
-
-					// clamp camera lag so that avatar is always in front
-					F32 dot = (mCameraLag - (frame_at_axis * (MIN_CAMERA_LAG * u))) * frame_at_axis;
-					if (dot < -(MIN_CAMERA_LAG * u))
-					{
-						mCameraLag -= (dot + (MIN_CAMERA_LAG * u)) * frame_at_axis;
-					}
-				}
-				else
-				{
-					mCameraLag = lerp(mCameraLag, LLVector3::zero, LLSmoothInterpolation::getInterpolant(0.15f));
-				}
-
-				camera_lag_d.setVec(mCameraLag);
-				camera_position_global = camera_position_global - camera_lag_d;
-			}
-		}
-	}
-	else
-	{
-		LLVector3d focusPosGlobal = calcFocusPositionTargetGlobal();
-		// camera gets pushed out later wrt mCameraFOVZoomFactor...this is "raw" value
-		camera_position_global = focusPosGlobal + mCameraFocusOffset;
-	}
-
-	if (!isDisableCameraConstraints() && !gAgent.isGodlike())
-	{
-		LLViewerRegion* regionp = LLWorld::getInstance()->getRegionFromPosGlobal(camera_position_global);
-		bool constrain = true;
-		if(regionp && regionp->canManageEstate())
-		{
-			constrain = false;
-		}
-		if(constrain)
-		{
-			F32 max_dist = (CAMERA_MODE_CUSTOMIZE_AVATAR == mCameraMode) ? APPEARANCE_MAX_ZOOM : mDrawDistance;
-
-			LLVector3d camera_offset = camera_position_global - gAgent.getPositionGlobal();
-			F32 camera_distance = (F32)camera_offset.magVec();
-
-			if(camera_distance > max_dist)
-			{
-				camera_position_global = gAgent.getPositionGlobal() + (max_dist/camera_distance)*camera_offset;
-				isConstrained = true;
-			}
-		}
-
-// JC - Could constrain camera based on parcel stuff here.
-//			LLViewerRegion *regionp = LLWorld::getInstance()->getRegionFromPosGlobal(camera_position_global);
-//			
-//			if (regionp && !regionp->mParcelOverlay->isBuildCameraAllowed(regionp->getPosRegionFromGlobal(camera_position_global)))
-//			{
-//				camera_position_global = last_position_global;
-//
-//				isConstrained = true;
-//			}
-	}
-
-	// Don't let camera go underground
-	F32 camera_min_off_ground = getCameraMinOffGround();
-	camera_land_height = LLWorld::getInstance()->resolveLandHeightGlobal(camera_position_global);
-	F32 minZ = llmax(F_ALMOST_ZERO, camera_land_height + camera_min_off_ground);
-	if (camera_position_global.mdV[VZ] < minZ)
-	{
-		camera_position_global.mdV[VZ] = minZ;
-		isConstrained = true;
-	}
-
-	if (hit_limit)
-	{
-		*hit_limit = isConstrained;
-	}
-
-	return camera_position_global;
-}
-
-
-LLVector3 LLAgentCamera::getCurrentCameraOffset()
-{
-	return (LLViewerCamera::getInstance()->getOrigin() - getAvatarRootPosition() - mThirdPersonHeadOffset) * ~getCurrentAvatarRotation();
-}
-
-LLVector3d LLAgentCamera::getCurrentFocusOffset()
-{
-	return (mFocusTargetGlobal - gAgent.getPositionGlobal()) * ~getCurrentAvatarRotation();
-}
-
-LLQuaternion LLAgentCamera::getCurrentAvatarRotation()
-{
-	LLViewerObject* sit_object = (LLViewerObject*)gAgentAvatarp->getParent();
-	
-	LLQuaternion av_rot = gAgent.getFrameAgent().getQuaternion();
-	LLQuaternion obj_rot = sit_object ? sit_object->getRenderRotation() : LLQuaternion::DEFAULT;
-	return av_rot * obj_rot;
-}
-
-bool LLAgentCamera::isJoystickCameraUsed()
-{
-	return ((mOrbitAroundRadians != 0) || (mOrbitOverAngle != 0) || !mPanFocusDiff.isNull());
-}
-
-LLVector3 LLAgentCamera::getCameraOffsetInitial()
-{
-    // getCameraOffsetInitial and getFocusOffsetInitial can be called on update from idle before init()
-    static LLCachedControl<LLVector3> camera_offset_initial (gSavedSettings, "CameraOffsetRearView", LLVector3());
-	return camera_offset_initial;
-}
-
-LLVector3d LLAgentCamera::getFocusOffsetInitial()
-{
-    static LLCachedControl<LLVector3d> focus_offset_initial(gSavedSettings, "FocusOffsetRearView", LLVector3d());
-	return focus_offset_initial;
-}
-
-F32 LLAgentCamera::getCameraMaxZoomDistance()
-{
-    // SL-14706 / SL-14885 TPV have relaxed camera constraints allowing you to mousewheeel zoom WAY out.
-    static LLCachedControl<bool> s_disable_camera_constraints(gSavedSettings, "DisableCameraConstraints", false);
-    if (s_disable_camera_constraints)
-    {
-        return (F32)INT_MAX;
-    }
-
-    // Ignore "DisableCameraConstraints", we don't want to be out of draw range when we focus onto objects or avatars
-    return llmin(MAX_CAMERA_DISTANCE_FROM_OBJECT,
-                 mDrawDistance - 1, // convenience, don't hit draw limit when focusing on something
-                 LLWorld::getInstance()->getRegionWidthInMeters() - CAMERA_FUDGE_FROM_OBJECT);
-}
-
-LLVector3 LLAgentCamera::getAvatarRootPosition()
-{
-    static LLCachedControl<bool> use_hover_height(gSavedSettings, "HoverHeightAffectsCamera");
-    return use_hover_height ? gAgentAvatarp->mRoot->getWorldPosition() : gAgentAvatarp->mRoot->getWorldPosition() - gAgentAvatarp->getHoverOffset();
-
-}
-//-----------------------------------------------------------------------------
-// handleScrollWheel()
-//-----------------------------------------------------------------------------
-void LLAgentCamera::handleScrollWheel(S32 clicks)
-{
-	if (mCameraMode == CAMERA_MODE_FOLLOW && getFocusOnAvatar())
-	{
-		if (!mFollowCam.getPositionLocked()) // not if the followCam position is locked in place
-		{
-			mFollowCam.zoom(clicks); 
-			if (mFollowCam.isZoomedToMinimumDistance())
-			{
-				changeCameraToMouselook(false);
-			}
-		}
-	}
-	else
-	{
-		LLObjectSelectionHandle selection = LLSelectMgr::getInstance()->getSelection();
-		const F32 ROOT_ROOT_TWO = sqrt(F_SQRT2);
-
-		// Block if camera is animating
-		if (mCameraAnimating)
-		{
-			return;
-		}
-
-		if (selection->getObjectCount() && selection->getSelectType() == SELECT_TYPE_HUD)
-		{
-			F32 zoom_factor = (F32)pow(0.8, -clicks);
-			cameraZoomIn(zoom_factor);
-		}
-		else if (mFocusOnAvatar && (mCameraMode == CAMERA_MODE_THIRD_PERSON))
-		{
-			F32 camera_offset_initial_mag = getCameraOffsetInitial().magVec();
-			
-			F32 current_zoom_fraction = mTargetCameraDistance / (camera_offset_initial_mag * gSavedSettings.getF32("CameraOffsetScale"));
-			current_zoom_fraction *= 1.f - pow(ROOT_ROOT_TWO, clicks);
-			
-			cameraOrbitIn(current_zoom_fraction * camera_offset_initial_mag * gSavedSettings.getF32("CameraOffsetScale"));
-		}
-		else
-		{
-			F32 current_zoom_fraction = (F32)mCameraFocusOffsetTarget.magVec();
-			cameraOrbitIn(current_zoom_fraction * (1.f - pow(ROOT_ROOT_TWO, clicks)));
-		}
-	}
-}
-
-
-//-----------------------------------------------------------------------------
-// getCameraMinOffGround()
-//-----------------------------------------------------------------------------
-F32 LLAgentCamera::getCameraMinOffGround()
-{
-	if (mCameraMode == CAMERA_MODE_MOUSELOOK)
-	{
-		return 0.f;
-	}
-
-	if (isDisableCameraConstraints())
-	{
-		return -1000.f;
-	}
-
-	return 0.5f;
-}
-
-
-//-----------------------------------------------------------------------------
-// resetCamera()
-//-----------------------------------------------------------------------------
-void LLAgentCamera::resetCamera()
-{
-	// Remove any pitch from the avatar
-	LLVector3 at = gAgent.getFrameAgent().getAtAxis();
-	at.mV[VZ] = 0.f;
-	at.normalize();
-	gAgent.resetAxes(at);
-	// have to explicitly clear field of view zoom now
-	mCameraFOVZoomFactor = 0.f;
-
-	updateCamera();
-}
-
-//-----------------------------------------------------------------------------
-// changeCameraToMouselook()
-//-----------------------------------------------------------------------------
-void LLAgentCamera::changeCameraToMouselook(bool animate)
-{
-	if (!gSavedSettings.getBOOL("EnableMouselook") 
-		|| LLViewerJoystick::getInstance()->getOverrideCamera())
-	{
-		return;
-	}
-	
-	// visibility changes at end of animation
-	gViewerWindow->getWindow()->resetBusyCount();
-
-	// Menus should not remain open on switching to mouselook...
-	LLMenuGL::sMenuContainer->hideMenus();
-	LLUI::getInstance()->clearPopups();
-
-	// unpause avatar animation
-	gAgent.unpauseAnimation();
-
-	LLToolMgr::getInstance()->setCurrentToolset(gMouselookToolset);
-
-	if (isAgentAvatarValid())
-	{
-		gAgentAvatarp->stopMotion(ANIM_AGENT_BODY_NOISE);
-		gAgentAvatarp->stopMotion(ANIM_AGENT_BREATHE_ROT);
-	}
-
-	//gViewerWindow->stopGrab();
-	LLSelectMgr::getInstance()->deselectAll();
-	gViewerWindow->hideCursor();
-	gViewerWindow->moveCursorToCenter();
-
-	if (mCameraMode != CAMERA_MODE_MOUSELOOK)
-	{
-		gFocusMgr.setKeyboardFocus(NULL);
-		
-		updateLastCamera();
-		mCameraMode = CAMERA_MODE_MOUSELOOK;
-		const U32 old_flags = gAgent.getControlFlags();
-		gAgent.setControlFlags(AGENT_CONTROL_MOUSELOOK);
-		if (old_flags != gAgent.getControlFlags())
-		{
-			gAgent.setFlagsDirty();
-		}
-
-		if (animate)
-		{
-			startCameraAnimation();
-		}
-		else
-		{
-			mCameraAnimating = false;
-			gAgent.endAnimationUpdateUI();
-		}
-	}
-}
-
-
-//-----------------------------------------------------------------------------
-// changeCameraToDefault()
-//-----------------------------------------------------------------------------
-void LLAgentCamera::changeCameraToDefault()
-{
-	if (LLViewerJoystick::getInstance()->getOverrideCamera())
-	{
-		return;
-	}
-
-	if (LLFollowCamMgr::getInstance()->getActiveFollowCamParams())
-	{
-		changeCameraToFollow();
-	}
-	else
-	{
-		changeCameraToThirdPerson();
-	}
-	if (gSavedSettings.getBOOL("HideUIControls"))
-	{
-		gViewerWindow->setUIVisibility(false);
-		LLPanelStandStopFlying::getInstance()->setVisible(false);
-	}
-}
-
-
-//-----------------------------------------------------------------------------
-// changeCameraToFollow()
-//-----------------------------------------------------------------------------
-void LLAgentCamera::changeCameraToFollow(bool animate)
-{
-	if (LLViewerJoystick::getInstance()->getOverrideCamera())
-	{
-		return;
-	}
-
-	if(mCameraMode != CAMERA_MODE_FOLLOW)
-	{
-		if (mCameraMode == CAMERA_MODE_MOUSELOOK)
-		{
-			animate = false;
-		}
-		startCameraAnimation();
-
-		updateLastCamera();
-		mCameraMode = CAMERA_MODE_FOLLOW;
-
-		// bang-in the current focus, position, and up vector of the follow cam
-		mFollowCam.reset(mCameraPositionAgent, LLViewerCamera::getInstance()->getPointOfInterest(), LLVector3::z_axis);
-		
-		if (gBasicToolset)
-		{
-			LLToolMgr::getInstance()->setCurrentToolset(gBasicToolset);
-		}
-
-		if (isAgentAvatarValid())
-		{
-			// SL-315
-			gAgentAvatarp->mPelvisp->setPosition(LLVector3::zero);
-			gAgentAvatarp->startMotion( ANIM_AGENT_BODY_NOISE );
-			gAgentAvatarp->startMotion( ANIM_AGENT_BREATHE_ROT );
-		}
-
-		// unpause avatar animation
-		gAgent.unpauseAnimation();
-
-		gAgent.clearControlFlags(AGENT_CONTROL_MOUSELOOK);
-
-		if (animate)
-		{
-			startCameraAnimation();
-		}
-		else
-		{
-			mCameraAnimating = false;
-			gAgent.endAnimationUpdateUI();
-		}
-	}
-}
-
-//-----------------------------------------------------------------------------
-// changeCameraToThirdPerson()
-//-----------------------------------------------------------------------------
-void LLAgentCamera::changeCameraToThirdPerson(bool animate)
-{
-	if (LLViewerJoystick::getInstance()->getOverrideCamera())
-	{
-		return;
-	}
-
-	gViewerWindow->getWindow()->resetBusyCount();
-
-	mCameraZoomFraction = INITIAL_ZOOM_FRACTION;
-
-	if (isAgentAvatarValid())
-	{
-		if (!gAgentAvatarp->isSitting())
-		{
-			// SL-315
-			gAgentAvatarp->mPelvisp->setPosition(LLVector3::zero);
-		}
-		gAgentAvatarp->startMotion(ANIM_AGENT_BODY_NOISE);
-		gAgentAvatarp->startMotion(ANIM_AGENT_BREATHE_ROT);
-	}
-
-	LLVector3 at_axis;
-
-	// unpause avatar animation
-	gAgent.unpauseAnimation();
-
-	if (mCameraMode != CAMERA_MODE_THIRD_PERSON)
-	{
-		if (gBasicToolset)
-		{
-			LLToolMgr::getInstance()->setCurrentToolset(gBasicToolset);
-		}
-
-		mCameraLag.clearVec();
-		if (mCameraMode == CAMERA_MODE_MOUSELOOK)
-		{
-			mCurrentCameraDistance = MIN_CAMERA_DISTANCE;
-			mTargetCameraDistance = MIN_CAMERA_DISTANCE;
-			animate = false;
-		}
-		updateLastCamera();
-		mCameraMode = CAMERA_MODE_THIRD_PERSON;
-		gAgent.clearControlFlags(AGENT_CONTROL_MOUSELOOK);
-	}
-
-	// Remove any pitch from the avatar
-	if (!isAgentAvatarValid() || !gAgentAvatarp->getParent())
-	{
-		at_axis = gAgent.getFrameAgent().getAtAxis();
-		at_axis.mV[VZ] = 0.f;
-		at_axis.normalize();
-		gAgent.resetAxes(at_axis);
-	}
-
-
-	if (animate)
-	{
-		startCameraAnimation();
-	}
-	else
-	{
-		mCameraAnimating = false;
-		gAgent.endAnimationUpdateUI();
-	}
-}
-
-//-----------------------------------------------------------------------------
-// changeCameraToCustomizeAvatar()
-//-----------------------------------------------------------------------------
-void LLAgentCamera::changeCameraToCustomizeAvatar()
-{
-	if (LLViewerJoystick::getInstance()->getOverrideCamera() || !isAgentAvatarValid())
-	{
-		return;
-	}
-
-	gAgent.standUp(); // force stand up
-	gViewerWindow->getWindow()->resetBusyCount();
-
-    if (LLSelectMgr::getInstance()->getSelection()->isAttachment())
-    {
-        LLSelectMgr::getInstance()->deselectAll();
-    }
-
-	if (gFaceEditToolset)
-	{
-		LLToolMgr::getInstance()->setCurrentToolset(gFaceEditToolset);
-	}
-
-	startCameraAnimation();
-
-	if (mCameraMode != CAMERA_MODE_CUSTOMIZE_AVATAR)
-	{
-		updateLastCamera();
-		mCameraMode = CAMERA_MODE_CUSTOMIZE_AVATAR;
-		gAgent.clearControlFlags(AGENT_CONTROL_MOUSELOOK);
-
-		gFocusMgr.setKeyboardFocus( NULL );
-		gFocusMgr.setMouseCapture( NULL );
-		if( gMorphView )
-		{
-			gMorphView->setVisible( true );
-		}
-		// Remove any pitch or rotation from the avatar
-		LLVector3 at = gAgent.getAtAxis();
-		at.mV[VZ] = 0.f;
-		at.normalize();
-		gAgent.resetAxes(at);
-
-		gAgent.sendAnimationRequest(ANIM_AGENT_CUSTOMIZE, ANIM_REQUEST_START);
-		gAgent.setCustomAnim(true);
-		gAgentAvatarp->startMotion(ANIM_AGENT_CUSTOMIZE);
-		LLMotion* turn_motion = gAgentAvatarp->findMotion(ANIM_AGENT_CUSTOMIZE);
-
-		if (turn_motion)
-		{
-			// delay camera animation long enough to play through turn animation
-			setAnimationDuration(turn_motion->getDuration() + CUSTOMIZE_AVATAR_CAMERA_ANIM_SLOP);
-		}
-	}
-
-	LLVector3 agent_at = gAgent.getAtAxis();
-	agent_at.mV[VZ] = 0.f;
-	agent_at.normalize();
-
-	// default focus point for customize avatar
-	LLVector3 focus_target = isAgentAvatarValid() 
-		? gAgentAvatarp->mHeadp->getWorldPosition()
-		: gAgent.getPositionAgent();
-
-	LLVector3d camera_offset(agent_at * -1.0);
-	// push camera up and out from avatar
-	camera_offset.mdV[VZ] = 0.1f; 
-	camera_offset *= CUSTOMIZE_AVATAR_CAMERA_DEFAULT_DIST;
-	LLVector3d focus_target_global = gAgent.getPosGlobalFromAgent(focus_target);
-	setAnimationDuration(gSavedSettings.getF32("ZoomTime"));
-	setCameraPosAndFocusGlobal(focus_target_global + camera_offset, focus_target_global, gAgent.getID());
-}
-
-
-void LLAgentCamera::switchCameraPreset(ECameraPreset preset)
-{
-	//zoom is supposed to be reset for the front and group views
-	mCameraZoomFraction = 1.f;
-
-	//focusing on avatar in that case means following him on movements
-	mFocusOnAvatar = true;
-
-	mCameraPreset = preset;
-
-	resetPanDiff();
-	resetOrbitDiff();
-
-	gSavedSettings.setU32("CameraPresetType", mCameraPreset);
-}
-
-
-//
-// Focus point management
-//
-
-void LLAgentCamera::setAnimationDuration(F32 duration)
-{ 
-	if (mCameraAnimating)
-	{
-		// do not cut any existing camera animation short
-		F32 animation_left = llmax(0.f, mAnimationDuration - mAnimationTimer.getElapsedTimeF32());
-		mAnimationDuration = llmax(duration, animation_left);
-	}
-	else
-	{
-		mAnimationDuration = duration; 
-	}
-}
-
-//-----------------------------------------------------------------------------
-// startCameraAnimation()
-//-----------------------------------------------------------------------------
-void LLAgentCamera::startCameraAnimation()
-{
-	mAnimationCameraStartGlobal = getCameraPositionGlobal();
-	mAnimationFocusStartGlobal = mFocusGlobal;
-	setAnimationDuration(gSavedSettings.getF32("ZoomTime"));
-	mAnimationTimer.reset();
-	mCameraAnimating = true;
-}
-
-//-----------------------------------------------------------------------------
-// stopCameraAnimation()
-//-----------------------------------------------------------------------------
-void LLAgentCamera::stopCameraAnimation()
-{
-	mCameraAnimating = false;
-}
-
-void LLAgentCamera::clearFocusObject()
-{
-	if (mFocusObject.notNull())
-	{
-		startCameraAnimation();
-
-		setFocusObject(NULL);
-		mFocusObjectOffset.clearVec();
-	}
-}
-
-void LLAgentCamera::setFocusObject(LLViewerObject* object)
-{
-	mFocusObject = object;
-}
-
-// Focus on a point, but try to keep camera position stable.
-//-----------------------------------------------------------------------------
-// setFocusGlobal()
-//-----------------------------------------------------------------------------
-void LLAgentCamera::setFocusGlobal(const LLPickInfo& pick)
-{
-	LLViewerObject* objectp = gObjectList.findObject(pick.mObjectID);
-
-	if (objectp)
-	{
-		// focus on object plus designated offset
-		// which may or may not be same as pick.mPosGlobal
-		setFocusGlobal(objectp->getPositionGlobal() + LLVector3d(pick.mObjectOffset), pick.mObjectID);
-	}
-	else
-	{
-		// focus directly on point where user clicked
-		setFocusGlobal(pick.mPosGlobal, pick.mObjectID);
-	}
-}
-
-
-void LLAgentCamera::setFocusGlobal(const LLVector3d& focus, const LLUUID &object_id)
-{
-	setFocusObject(gObjectList.findObject(object_id));
-	LLVector3d old_focus = mFocusTargetGlobal;
-	LLViewerObject *focus_obj = mFocusObject;
-
-	// if focus has changed
-	if (old_focus != focus)
-	{
-		if (focus.isExactlyZero())
-		{
-			if (isAgentAvatarValid())
-			{
-				mFocusTargetGlobal = gAgent.getPosGlobalFromAgent(gAgentAvatarp->mHeadp->getWorldPosition());
-			}
-			else
-			{
-				mFocusTargetGlobal = gAgent.getPositionGlobal();
-			}
-			mCameraFocusOffsetTarget = getCameraPositionGlobal() - mFocusTargetGlobal;
-			mCameraFocusOffset = mCameraFocusOffsetTarget;
-			setLookAt(LOOKAT_TARGET_CLEAR);
-		}
-		else
-		{
-			mFocusTargetGlobal = focus;
-			if (!focus_obj)
-			{
-				mCameraFOVZoomFactor = 0.f;
-			}
-
-			mCameraFocusOffsetTarget = gAgent.getPosGlobalFromAgent(mCameraVirtualPositionAgent) - mFocusTargetGlobal;
-
-			startCameraAnimation();
-
-			if (focus_obj)
-			{
-				if (focus_obj->isAvatar())
-				{
-					setLookAt(LOOKAT_TARGET_FOCUS, focus_obj);
-				}
-				else
-				{
-					setLookAt(LOOKAT_TARGET_FOCUS, focus_obj, (gAgent.getPosAgentFromGlobal(focus) - focus_obj->getRenderPosition()) * ~focus_obj->getRenderRotation());
-				}
-			}
-			else
-			{
-				setLookAt(LOOKAT_TARGET_FOCUS, NULL, gAgent.getPosAgentFromGlobal(mFocusTargetGlobal));
-			}
-		}
-	}
-	else // focus == mFocusTargetGlobal
-	{
-		if (focus.isExactlyZero())
-		{
-			if (isAgentAvatarValid())
-			{
-				mFocusTargetGlobal = gAgent.getPosGlobalFromAgent(gAgentAvatarp->mHeadp->getWorldPosition());
-			}
-			else
-			{
-				mFocusTargetGlobal = gAgent.getPositionGlobal();
-			}
-		}
-		mCameraFocusOffsetTarget = (getCameraPositionGlobal() - mFocusTargetGlobal) / (1.f + mCameraFOVZoomFactor);;
-		mCameraFocusOffset = mCameraFocusOffsetTarget;
-	}
-
-	if (mFocusObject.notNull())
-	{
-		// for attachments, make offset relative to avatar, not the attachment
-		if (mFocusObject->isAttachment())
-		{
-			while (mFocusObject.notNull() && !mFocusObject->isAvatar())
-			{
-				mFocusObject = (LLViewerObject*) mFocusObject->getParent();
-			}
-			setFocusObject((LLViewerObject*)mFocusObject);
-		}
-		updateFocusOffset();
-	}
-}
-
-// Used for avatar customization
-//-----------------------------------------------------------------------------
-// setCameraPosAndFocusGlobal()
-//-----------------------------------------------------------------------------
-void LLAgentCamera::setCameraPosAndFocusGlobal(const LLVector3d& camera_pos, const LLVector3d& focus, const LLUUID &object_id)
-{
-	LLVector3d old_focus = mFocusTargetGlobal.isExactlyZero() ? focus : mFocusTargetGlobal;
-
-	F64 focus_delta_squared = (old_focus - focus).magVecSquared();
-	const F64 ANIM_EPSILON_SQUARED = 0.0001;
-	if (focus_delta_squared > ANIM_EPSILON_SQUARED)
-	{
-		startCameraAnimation();
-	}
-	
-	//LLViewerCamera::getInstance()->setOrigin( gAgent.getPosAgentFromGlobal( camera_pos ) );
-	setFocusObject(gObjectList.findObject(object_id));
-	mFocusTargetGlobal = focus;
-	mCameraFocusOffsetTarget = camera_pos - focus;
-	mCameraFocusOffset = mCameraFocusOffsetTarget;
-
-	if (mFocusObject)
-	{
-		if (mFocusObject->isAvatar())
-		{
-			setLookAt(LOOKAT_TARGET_FOCUS, mFocusObject);
-		}
-		else
-		{
-			setLookAt(LOOKAT_TARGET_FOCUS, mFocusObject, (gAgent.getPosAgentFromGlobal(focus) - mFocusObject->getRenderPosition()) * ~mFocusObject->getRenderRotation());
-		}
-	}
-	else
-	{
-		setLookAt(LOOKAT_TARGET_FOCUS, NULL, gAgent.getPosAgentFromGlobal(mFocusTargetGlobal));
-	}
-
-	if (mCameraAnimating)
-	{
-		const F64 ANIM_METERS_PER_SECOND = 10.0;
-		const F64 MIN_ANIM_SECONDS = 0.5;
-		const F64 MAX_ANIM_SECONDS = 10.0;
-		F64 anim_duration = llmax( MIN_ANIM_SECONDS, sqrt(focus_delta_squared) / ANIM_METERS_PER_SECOND );
-		anim_duration = llmin( anim_duration, MAX_ANIM_SECONDS );
-		setAnimationDuration( (F32)anim_duration );
-	}
-
-	updateFocusOffset();
-}
-
-//-----------------------------------------------------------------------------
-// setSitCamera()
-//-----------------------------------------------------------------------------
-void LLAgentCamera::setSitCamera(const LLUUID &object_id, const LLVector3 &camera_pos, const LLVector3 &camera_focus)
-{
-	bool camera_enabled = !object_id.isNull();
-
-	if (camera_enabled)
-	{
-		LLViewerObject *reference_object = gObjectList.findObject(object_id);
-		if (reference_object)
-		{
-			//convert to root object relative?
-			mSitCameraPos = camera_pos;
-			mSitCameraFocus = camera_focus;
-			mSitCameraReferenceObject = reference_object;
-			mSitCameraEnabled = true;
-		}
-	}
-	else
-	{
-		mSitCameraPos.clearVec();
-		mSitCameraFocus.clearVec();
-		mSitCameraReferenceObject = NULL;
-		mSitCameraEnabled = false;
-	}
-}
-
-//-----------------------------------------------------------------------------
-// setFocusOnAvatar()
-//-----------------------------------------------------------------------------
-void LLAgentCamera::setFocusOnAvatar(bool focus_on_avatar, bool animate, bool reset_axes)
-{
-	if (focus_on_avatar != mFocusOnAvatar)
-	{
-		if (animate)
-		{
-			startCameraAnimation();
-		}
-		else
-		{
-			stopCameraAnimation();
-		}
-	}
-	
-	//RN: when focused on the avatar, we're not "looking" at it
-	// looking implies intent while focusing on avatar means
-	// you're just walking around with a camera on you...eesh.
-	if (!mFocusOnAvatar && focus_on_avatar && reset_axes)
-	{
-		setFocusGlobal(LLVector3d::zero);
-		mCameraFOVZoomFactor = 0.f;
-		if (mCameraMode == CAMERA_MODE_THIRD_PERSON)
-		{
-			LLVector3 at_axis;
-			if (!isAgentAvatarValid() || !gAgentAvatarp->getParent())
-			{
-                // In case of front view rotate agent to look into direction opposite to camera
-                // In case of rear view rotate agent into diraction same as camera, e t c
-                LLVector3 vect = getCameraOffsetInitial();
-                F32 rotxy = F32(atan2(vect.mV[VY], vect.mV[VX]));
-
-                LLCoordFrame frameCamera = *((LLCoordFrame*)LLViewerCamera::getInstance());
-                // front view angle rotxy is zero, rear view rotxy angle is 180, compensate
-                frameCamera.yaw((180 * DEG_TO_RAD) - rotxy);
-                at_axis = frameCamera.getAtAxis();
-                at_axis.mV[VZ] = 0.f;
-                at_axis.normalize();
-                gAgent.resetAxes(at_axis);
-                gAgent.yaw(0);
-			}
-		}
-	}
-	// unlocking camera from avatar
-	else if (mFocusOnAvatar && !focus_on_avatar)
-	{
-		// keep camera focus point consistent, even though it is now unlocked
-		setFocusGlobal(gAgent.getPositionGlobal() + calcThirdPersonFocusOffset(), gAgent.getID());
-		mAllowChangeToFollow = false;
-	}
-	
-	mFocusOnAvatar = focus_on_avatar;
-}
-
-
-bool LLAgentCamera::setLookAt(ELookAtType target_type, LLViewerObject *object, LLVector3 position)
-{
-	if(object && object->isAttachment())
-	{
-		LLViewerObject* parent = object;
-		while(parent)
-		{
-			if (parent == gAgentAvatarp)
-			{
-				// looking at an attachment on ourselves, which we don't want to do
-				object = gAgentAvatarp;
-				position.clearVec();
-			}
-			parent = (LLViewerObject*)parent->getParent();
-		}
-	}
-	if(!mLookAt || mLookAt->isDead())
-	{
-		mLookAt = (LLHUDEffectLookAt *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_LOOKAT);
-		mLookAt->setSourceObject(gAgentAvatarp);
-	}
-
-	return mLookAt->setLookAt(target_type, object, position);
-}
-
-//-----------------------------------------------------------------------------
-// lookAtLastChat()
-//-----------------------------------------------------------------------------
-void LLAgentCamera::lookAtLastChat()
-{
-	// Block if camera is animating or not in normal third person camera mode
-	if (mCameraAnimating || !cameraThirdPerson())
-	{
-		return;
-	}
-
-	LLViewerObject *chatter = gObjectList.findObject(gAgent.getLastChatter());
-	if (!chatter)
-	{
-		return;
-	}
-
-	LLVector3 delta_pos;
-	if (chatter->isAvatar())
-	{
-		LLVOAvatar *chatter_av = (LLVOAvatar*)chatter;
-		if (isAgentAvatarValid() && chatter_av->mHeadp)
-		{
-			delta_pos = chatter_av->mHeadp->getWorldPosition() - gAgentAvatarp->mHeadp->getWorldPosition();
-		}
-		else
-		{
-			delta_pos = chatter->getPositionAgent() - gAgent.getPositionAgent();
-		}
-		delta_pos.normalize();
-
-		gAgent.setControlFlags(AGENT_CONTROL_STOP);
-
-		changeCameraToThirdPerson();
-
-		LLVector3 new_camera_pos = gAgentAvatarp->mHeadp->getWorldPosition();
-		LLVector3 left = delta_pos % LLVector3::z_axis;
-		left.normalize();
-		LLVector3 up = left % delta_pos;
-		up.normalize();
-		new_camera_pos -= delta_pos * 0.4f;
-		new_camera_pos += left * 0.3f;
-		new_camera_pos += up * 0.2f;
-
-		setFocusOnAvatar(false, false);
-
-		if (chatter_av->mHeadp)
-		{
-			setFocusGlobal(gAgent.getPosGlobalFromAgent(chatter_av->mHeadp->getWorldPosition()), gAgent.getLastChatter());
-			mCameraFocusOffsetTarget = gAgent.getPosGlobalFromAgent(new_camera_pos) - gAgent.getPosGlobalFromAgent(chatter_av->mHeadp->getWorldPosition());
-		}
-		else
-		{
-			setFocusGlobal(chatter->getPositionGlobal(), gAgent.getLastChatter());
-			mCameraFocusOffsetTarget = gAgent.getPosGlobalFromAgent(new_camera_pos) - chatter->getPositionGlobal();
-		}
-	}
-	else
-	{
-		delta_pos = chatter->getRenderPosition() - gAgent.getPositionAgent();
-		delta_pos.normalize();
-
-		gAgent.setControlFlags(AGENT_CONTROL_STOP);
-
-		changeCameraToThirdPerson();
-
-		LLVector3 new_camera_pos = gAgentAvatarp->mHeadp->getWorldPosition();
-		LLVector3 left = delta_pos % LLVector3::z_axis;
-		left.normalize();
-		LLVector3 up = left % delta_pos;
-		up.normalize();
-		new_camera_pos -= delta_pos * 0.4f;
-		new_camera_pos += left * 0.3f;
-		new_camera_pos += up * 0.2f;
-
-		setFocusOnAvatar(false, false);
-
-		setFocusGlobal(chatter->getPositionGlobal(), gAgent.getLastChatter());
-		mCameraFocusOffsetTarget = gAgent.getPosGlobalFromAgent(new_camera_pos) - chatter->getPositionGlobal();
-	}
-}
-
-bool LLAgentCamera::isfollowCamLocked()
-{
-	return mFollowCam.getPositionLocked();
-}
-
-bool LLAgentCamera::setPointAt(EPointAtType target_type, LLViewerObject *object, LLVector3 position)
-{
-	// disallow pointing at attachments and avatars
-	if (object && (object->isAttachment() || object->isAvatar()))
-	{
-		return false;
-	}
-	if (!mPointAt || mPointAt->isDead())
-	{
-		mPointAt = (LLHUDEffectPointAt *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_POINTAT);
-		mPointAt->setSourceObject(gAgentAvatarp);
-	}
-	return mPointAt->setPointAt(target_type, object, position);
-}
-
-void LLAgentCamera::rotateToInitSitRot()
-{
-	gAgent.rotate(~gAgent.getFrameAgent().getQuaternion());
-	gAgent.rotate(mInitSitRot);
-}
-
-void LLAgentCamera::resetCameraZoomFraction()
-{ 
-	mCameraZoomFraction = INITIAL_ZOOM_FRACTION; 
-}
-
-ELookAtType LLAgentCamera::getLookAtType()
-{
-	if (mLookAt) 
-	{
-		return mLookAt->getLookAtType();
-	}
-	return LOOKAT_TARGET_NONE;
-}
-
-EPointAtType LLAgentCamera::getPointAtType()
-{ 
-	if (mPointAt) 
-	{
-		return mPointAt->getPointAtType();
-	}
-	return POINTAT_TARGET_NONE;
-}
-
-void LLAgentCamera::clearGeneralKeys()
-{
-	mAtKey 				= 0;
-	mWalkKey 			= 0;
-	mLeftKey 			= 0;
-	mUpKey 				= 0;
-	mYawKey 			= 0.f;
-	mPitchKey 			= 0.f;
-}
-
-void LLAgentCamera::clearOrbitKeys()
-{
-	mOrbitLeftKey		= 0.f;
-	mOrbitRightKey		= 0.f;
-	mOrbitUpKey			= 0.f;
-	mOrbitDownKey		= 0.f;
-	mOrbitInKey			= 0.f;
-	mOrbitOutKey		= 0.f;
-}
-
-void LLAgentCamera::clearPanKeys()
-{
-	mPanRightKey		= 0.f;
-	mPanLeftKey			= 0.f;
-	mPanUpKey			= 0.f;
-	mPanDownKey			= 0.f;
-	mPanInKey			= 0.f;
-	mPanOutKey			= 0.f;
-}
-
-// static
-S32 LLAgentCamera::directionToKey(S32 direction)
-{
-	if (direction > 0) return 1;
-	if (direction < 0) return -1;
-	return 0;
-}
-
-
-// EOF
-
+/**

+ * @file llagentcamera.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 "llagentcamera.h"

+

+#include "pipeline.h"

+

+#include "llagent.h"

+#include "llanimationstates.h"

+#include "llfloatercamera.h"

+#include "llfloaterreg.h"

+#include "llhudmanager.h"

+#include "lljoystickbutton.h"

+#include "llmorphview.h"

+#include "llmoveview.h"

+#include "llselectmgr.h"

+#include "llsmoothstep.h"

+#include "lltoolmgr.h"

+#include "llviewercamera.h"

+#include "llviewercontrol.h"

+#include "llviewerjoystick.h"

+#include "llviewermenu.h"

+#include "llviewerobjectlist.h"

+#include "llviewerregion.h"

+#include "llviewerwindow.h"

+#include "llvoavatarself.h"

+#include "llwindow.h"

+#include "llworld.h"

+

+using namespace LLAvatarAppearanceDefines;

+

+extern LLMenuBarGL* gMenuBarView;

+

+// Mousewheel camera zoom

+const F32 MIN_ZOOM_FRACTION = 0.25f;

+const F32 INITIAL_ZOOM_FRACTION = 1.f;

+const F32 MAX_ZOOM_FRACTION = 8.f;

+

+const F32 CAMERA_ZOOM_HALF_LIFE = 0.07f;    // seconds

+const F32 FOV_ZOOM_HALF_LIFE = 0.07f;   // seconds

+

+const F32 CAMERA_FOCUS_HALF_LIFE = 0.f;//0.02f;

+const F32 CAMERA_LAG_HALF_LIFE = 0.25f;

+const F32 MIN_CAMERA_LAG = 0.5f;

+const F32 MAX_CAMERA_LAG = 5.f;

+

+const F32 CAMERA_COLLIDE_EPSILON = 0.1f;

+const F32 MIN_CAMERA_DISTANCE = 0.1f;

+

+const F32 AVATAR_ZOOM_MIN_X_FACTOR = 0.55f;

+const F32 AVATAR_ZOOM_MIN_Y_FACTOR = 0.7f;

+const F32 AVATAR_ZOOM_MIN_Z_FACTOR = 1.15f;

+

+const F32 MAX_CAMERA_DISTANCE_FROM_AGENT = 50.f;

+const F32 MAX_CAMERA_DISTANCE_FROM_OBJECT = 496.f;

+const F32 CAMERA_FUDGE_FROM_OBJECT = 16.f;

+

+const F32 MAX_CAMERA_SMOOTH_DISTANCE = 50.0f;

+

+const F32 HEAD_BUFFER_SIZE = 0.3f;

+

+const F32 CUSTOMIZE_AVATAR_CAMERA_ANIM_SLOP = 0.1f;

+

+const F32 LAND_MIN_ZOOM = 0.15f;

+

+const F32 AVATAR_MIN_ZOOM = 0.5f;

+const F32 OBJECT_MIN_ZOOM = 0.02f;

+

+const F32 APPEARANCE_MIN_ZOOM = 0.39f;

+const F32 APPEARANCE_MAX_ZOOM = 8.f;

+

+const F32 CUSTOMIZE_AVATAR_CAMERA_DEFAULT_DIST = 3.5f;

+

+const F32 GROUND_TO_AIR_CAMERA_TRANSITION_TIME = 0.5f;

+const F32 GROUND_TO_AIR_CAMERA_TRANSITION_START_TIME = 0.5f;

+

+const F32 OBJECT_EXTENTS_PADDING = 0.5f;

+

+static bool isDisableCameraConstraints()

+{

+    static LLCachedControl<bool> sDisableCameraConstraints(gSavedSettings, "DisableCameraConstraints", false);

+    return sDisableCameraConstraints;

+}

+

+// The agent instance.

+LLAgentCamera gAgentCamera;

+

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

+// LLAgentCamera()

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

+LLAgentCamera::LLAgentCamera() :

+    mInitialized(false),

+

+    mDrawDistance( DEFAULT_FAR_PLANE ),

+

+    mLookAt(NULL),

+    mPointAt(NULL),

+

+    mHUDTargetZoom(1.f),

+    mHUDCurZoom(1.f),

+

+    mForceMouselook(false),

+

+    mCameraMode( CAMERA_MODE_THIRD_PERSON ),

+    mLastCameraMode( CAMERA_MODE_THIRD_PERSON ),

+

+    mCameraPreset(CAMERA_PRESET_REAR_VIEW),

+

+    mCameraAnimating( false ),

+    mAnimationCameraStartGlobal(),

+    mAnimationFocusStartGlobal(),

+    mAnimationTimer(),

+    mAnimationDuration(0.33f),

+

+    mCameraFOVZoomFactor(0.f),

+    mCameraCurrentFOVZoomFactor(0.f),

+    mCameraFocusOffset(),

+

+    mCameraCollidePlane(),

+

+    mCurrentCameraDistance(2.f),        // meters, set in init()

+    mTargetCameraDistance(2.f),

+    mCameraZoomFraction(1.f),           // deprecated

+    mThirdPersonHeadOffset(0.f, 0.f, 1.f),

+    mSitCameraEnabled(false),

+    mCameraSmoothingLastPositionGlobal(),

+    mCameraSmoothingLastPositionAgent(),

+    mCameraSmoothingStop(false),

+

+    mCameraUpVector(LLVector3::z_axis), // default is straight up

+

+    mFocusOnAvatar(true),

+    mAllowChangeToFollow(false),

+    mFocusGlobal(),

+    mFocusTargetGlobal(),

+    mFocusObject(NULL),

+    mFocusObjectDist(0.f),

+    mFocusObjectOffset(),

+    mTrackFocusObject(true),

+

+    mAtKey(0), // Either 1, 0, or -1... indicates that movement-key is pressed

+    mWalkKey(0), // like AtKey, but causes less forward thrust

+    mLeftKey(0),

+    mUpKey(0),

+    mYawKey(0.f),

+    mPitchKey(0.f),

+

+    mOrbitLeftKey(0.f),

+    mOrbitRightKey(0.f),

+    mOrbitUpKey(0.f),

+    mOrbitDownKey(0.f),

+    mOrbitInKey(0.f),

+    mOrbitOutKey(0.f),

+

+    mPanUpKey(0.f),

+    mPanDownKey(0.f),

+    mPanLeftKey(0.f),

+    mPanRightKey(0.f),

+    mPanInKey(0.f),

+    mPanOutKey(0.f)

+{

+    mFollowCam.setMaxCameraDistantFromSubject( MAX_CAMERA_DISTANCE_FROM_AGENT );

+

+    clearGeneralKeys();

+    clearOrbitKeys();

+    clearPanKeys();

+

+    resetPanDiff();

+    resetOrbitDiff();

+}

+

+// Requires gSavedSettings to be initialized.

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

+// init()

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

+void LLAgentCamera::init()

+{

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

+

+    mDrawDistance = gSavedSettings.getF32("RenderFarClip");

+

+    LLViewerCamera::getInstance()->setView(DEFAULT_FIELD_OF_VIEW);

+    // Leave at 0.1 meters until we have real near clip management

+    LLViewerCamera::getInstance()->setNear(0.1f);

+    LLViewerCamera::getInstance()->setFar(mDrawDistance);           // if you want to change camera settings, do so in camera.h

+    LLViewerCamera::getInstance()->setAspect( gViewerWindow->getWorldViewAspectRatio() );       // default, overridden in LLViewerWindow::reshape

+    LLViewerCamera::getInstance()->setViewHeightInPixels(768);          // default, overridden in LLViewerWindow::reshape

+

+    mCameraFocusOffsetTarget = LLVector4(gSavedSettings.getVector3("CameraOffsetBuild"));

+

+    mCameraPreset = (ECameraPreset) gSavedSettings.getU32("CameraPresetType");

+

+    mCameraCollidePlane.clearVec();

+    mCurrentCameraDistance = getCameraOffsetInitial().magVec() * gSavedSettings.getF32("CameraOffsetScale");

+    mTargetCameraDistance = mCurrentCameraDistance;

+    mCameraZoomFraction = 1.f;

+    mTrackFocusObject = gSavedSettings.getBOOL("TrackFocusObject");

+

+    mInitialized = true;

+}

+

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

+// cleanup()

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

+void LLAgentCamera::cleanup()

+{

+    setSitCamera(LLUUID::null);

+

+    if(mLookAt)

+    {

+        mLookAt->markDead() ;

+        mLookAt = NULL;

+    }

+    if(mPointAt)

+    {

+        mPointAt->markDead() ;

+        mPointAt = NULL;

+    }

+    setFocusObject(NULL);

+}

+

+void LLAgentCamera::setAvatarObject(LLVOAvatarSelf* avatar)

+{

+    if (!mLookAt)

+    {

+        mLookAt = (LLHUDEffectLookAt *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_LOOKAT);

+    }

+    if (!mPointAt)

+    {

+        mPointAt = (LLHUDEffectPointAt *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_POINTAT);

+    }

+

+    if (!mLookAt.isNull())

+    {

+        mLookAt->setSourceObject(avatar);

+    }

+    if (!mPointAt.isNull())

+    {

+        mPointAt->setSourceObject(avatar);

+    }

+}

+

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

+// LLAgent()

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

+LLAgentCamera::~LLAgentCamera()

+{

+    cleanup();

+

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

+}

+

+// Change camera back to third person, stop the autopilot,

+// deselect stuff, etc.

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

+// resetView()

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

+void LLAgentCamera::resetView(bool reset_camera, bool change_camera)

+{

+    if (gDisconnected)

+    {

+        return;

+    }

+

+    if (gAgent.getAutoPilot())

+    {

+        gAgent.stopAutoPilot(true);

+    }

+

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

+

+    // By popular request, keep land selection while walking around. JC

+    // LLViewerParcelMgr::getInstance()->deselectLand();

+

+    // force deselect when walking and attachment is selected

+    // this is so people don't wig out when their avatar moves without animating

+    if (LLSelectMgr::getInstance()->getSelection()->isAttachment())

+    {

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

+    }

+

+    if (gMenuHolder != NULL)

+    {

+        // Hide all popup menus

+        gMenuHolder->hideMenus();

+    }

+

+    if (change_camera && !gSavedSettings.getBOOL("FreezeTime"))

+    {

+        changeCameraToDefault();

+

+        if (LLViewerJoystick::getInstance()->getOverrideCamera())

+        {

+            handle_toggle_flycam();

+        }

+

+        // reset avatar mode from eventual residual motion

+        if (LLToolMgr::getInstance()->inBuildMode())

+        {

+            LLViewerJoystick::getInstance()->moveAvatar(true);

+        }

+

+        //Camera Tool is needed for Free Camera Control Mode

+        if (!LLFloaterCamera::inFreeCameraMode())

+        {

+            LLFloaterReg::hideInstance("build");

+

+            // Switch back to basic toolset

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

+        }

+

+        gViewerWindow->showCursor();

+    }

+

+

+    if (reset_camera && !gSavedSettings.getBOOL("FreezeTime"))

+    {

+        if (!gViewerWindow->getLeftMouseDown() && cameraThirdPerson())

+        {

+            // leaving mouse-steer mode

+            LLVector3 agent_at_axis = gAgent.getAtAxis();

+            agent_at_axis -= projected_vec(agent_at_axis, gAgent.getReferenceUpVector());

+            agent_at_axis.normalize();

+            gAgent.resetAxes(lerp(gAgent.getAtAxis(), agent_at_axis, LLSmoothInterpolation::getInterpolant(0.3f)));

+        }

+

+        setFocusOnAvatar(true, ANIMATE);

+

+        mCameraFOVZoomFactor = 0.f;

+    }

+    resetPanDiff();

+    resetOrbitDiff();

+    mHUDTargetZoom = 1.f;

+

+    if (LLSelectMgr::getInstance()->mAllowSelectAvatar)

+    {

+        // resetting camera also resets position overrides in debug mode 'AllowSelectAvatar'

+        LLObjectSelectionHandle selected_handle = LLSelectMgr::getInstance()->getSelection();

+        if (selected_handle->getObjectCount() == 1

+            && selected_handle->getFirstObject() != NULL

+            && selected_handle->getFirstObject()->isAvatar())

+        {

+            LLSelectMgr::getInstance()->resetObjectOverrides(selected_handle);

+        }

+    }

+}

+

+// Allow camera to be moved somewhere other than behind avatar.

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

+// unlockView()

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

+void LLAgentCamera::unlockView()

+{

+    if (getFocusOnAvatar())

+    {

+        if (isAgentAvatarValid())

+        {

+            setFocusGlobal(LLVector3d::zero, gAgentAvatarp->mID);

+        }

+        setFocusOnAvatar(false, false); // no animation

+    }

+}

+

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

+// slamLookAt()

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

+void LLAgentCamera::slamLookAt(const LLVector3 &look_at)

+{

+    LLVector3 look_at_norm = look_at;

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

+    look_at_norm.normalize();

+    gAgent.resetAxes(look_at_norm);

+}

+

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

+// calcFocusOffset()

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

+LLVector3 LLAgentCamera::calcFocusOffset(LLViewerObject *object, LLVector3 original_focus_point, S32 x, S32 y)

+{

+    LLMatrix4 obj_matrix = object->getRenderMatrix();

+    LLQuaternion obj_rot = object->getRenderRotation();

+    LLVector3 obj_pos = object->getRenderPosition();

+

+    // if is avatar - don't do any funk heuristics to position the focal point

+    // see DEV-30589

+    if ((object->isAvatar() && !object->isRoot()) || (object->isAnimatedObject() && object->getControlAvatar()))

+    {

+        return original_focus_point - obj_pos;

+    }

+    if (object->isAvatar())

+    {

+        LLVOAvatar* av = object->asAvatar();

+        return original_focus_point - av->getCharacterPosition();

+    }

+

+    LLQuaternion inv_obj_rot = ~obj_rot; // get inverse of rotation

+    LLVector3 object_extents = object->getScale();

+

+    // make sure they object extents are non-zero

+    object_extents.clamp(0.001f, F32_MAX);

+

+    // obj_to_cam_ray is unit vector pointing from object center to camera, in the coordinate frame of the object

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

+    obj_to_cam_ray.rotVec(inv_obj_rot);

+    obj_to_cam_ray.normalize();

+

+    // obj_to_cam_ray_proportions are the (positive) ratios of

+    // the obj_to_cam_ray x,y,z components with the x,y,z object dimensions.

+    LLVector3 obj_to_cam_ray_proportions;

+    obj_to_cam_ray_proportions.mV[VX] = llabs(obj_to_cam_ray.mV[VX] / object_extents.mV[VX]);

+    obj_to_cam_ray_proportions.mV[VY] = llabs(obj_to_cam_ray.mV[VY] / object_extents.mV[VY]);

+    obj_to_cam_ray_proportions.mV[VZ] = llabs(obj_to_cam_ray.mV[VZ] / object_extents.mV[VZ]);

+

+    // find the largest ratio stored in obj_to_cam_ray_proportions

+    // this corresponds to the object's local axial plane (XY, YZ, XZ) that is *most* facing the camera

+    LLVector3 longest_object_axis;

+    // is x-axis longest?

+    if (obj_to_cam_ray_proportions.mV[VX] > obj_to_cam_ray_proportions.mV[VY]

+        && obj_to_cam_ray_proportions.mV[VX] > obj_to_cam_ray_proportions.mV[VZ])

+    {

+        // then grab it

+        longest_object_axis.setVec(obj_matrix.getFwdRow4());

+    }

+    // is y-axis longest?

+    else if (obj_to_cam_ray_proportions.mV[VY] > obj_to_cam_ray_proportions.mV[VZ])

+    {

+        // then grab it

+        longest_object_axis.setVec(obj_matrix.getLeftRow4());

+    }

+    // otherwise, use z axis

+    else

+    {

+        longest_object_axis.setVec(obj_matrix.getUpRow4());

+    }

+

+    // Use this axis as the normal to project mouse click on to plane with that normal, at the object center.

+    // This generates a point behind the mouse cursor that is approximately in the middle of the object in

+    // terms of depth.

+    // We do this to allow the camera rotation tool to "tumble" the object by rotating the camera.

+    // If the focus point were the object surface under the mouse, camera rotation would introduce an undesirable

+    // eccentricity to the object orientation

+    LLVector3 focus_plane_normal(longest_object_axis);

+    focus_plane_normal.normalize();

+

+    LLVector3d focus_pt_global;

+    gViewerWindow->mousePointOnPlaneGlobal(focus_pt_global, x, y, gAgent.getPosGlobalFromAgent(obj_pos), focus_plane_normal);

+    LLVector3 focus_pt = gAgent.getPosAgentFromGlobal(focus_pt_global);

+

+    // find vector from camera to focus point in object space

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

+    camera_to_focus_vec.rotVec(inv_obj_rot);

+

+    // find vector from object origin to focus point in object coordinates

+    LLVector3 focus_offset_from_object_center = focus_pt - obj_pos;

+    // convert to object-local space

+    focus_offset_from_object_center.rotVec(inv_obj_rot);

+

+    // We need to project the focus point back into the bounding box of the focused object.

+    // Do this by calculating the XYZ scale factors needed to get focus offset back in bounds along the camera_focus axis

+    LLVector3 clip_fraction;

+

+    // for each axis...

+    for (U32 axis = VX; axis <= VZ; axis++)

+    {

+        //...calculate distance that focus offset sits outside of bounding box along that axis...

+        //NOTE: dist_out_of_bounds keeps the sign of focus_offset_from_object_center

+        F32 dist_out_of_bounds;

+        if (focus_offset_from_object_center.mV[axis] > 0.f)

+        {

+            dist_out_of_bounds = llmax(0.f, focus_offset_from_object_center.mV[axis] - (object_extents.mV[axis] * 0.5f));

+        }

+        else

+        {

+            dist_out_of_bounds = llmin(0.f, focus_offset_from_object_center.mV[axis] + (object_extents.mV[axis] * 0.5f));

+        }

+

+        //...then calculate the scale factor needed to push camera_to_focus_vec back in bounds along current axis

+        if (llabs(camera_to_focus_vec.mV[axis]) < 0.0001f)

+        {

+            // don't divide by very small number

+            clip_fraction.mV[axis] = 0.f;

+        }

+        else

+        {

+            clip_fraction.mV[axis] = dist_out_of_bounds / camera_to_focus_vec.mV[axis];

+        }

+    }

+

+    LLVector3 abs_clip_fraction = clip_fraction;

+    abs_clip_fraction.abs();

+

+    // find axis of focus offset that is *most* outside the bounding box and use that to

+    // rescale focus offset to inside object extents

+    if (abs_clip_fraction.mV[VX] > abs_clip_fraction.mV[VY]

+        && abs_clip_fraction.mV[VX] > abs_clip_fraction.mV[VZ])

+    {

+        focus_offset_from_object_center -= clip_fraction.mV[VX] * camera_to_focus_vec;

+    }

+    else if (abs_clip_fraction.mV[VY] > abs_clip_fraction.mV[VZ])

+    {

+        focus_offset_from_object_center -= clip_fraction.mV[VY] * camera_to_focus_vec;

+    }

+    else

+    {

+        focus_offset_from_object_center -= clip_fraction.mV[VZ] * camera_to_focus_vec;

+    }

+

+    // convert back to world space

+    focus_offset_from_object_center.rotVec(obj_rot);

+

+    // now, based on distance of camera from object relative to object size

+    // push the focus point towards the near surface of the object when (relatively) close to the objcet

+    // or keep the focus point in the object middle when (relatively) far

+    // NOTE: leave focus point in middle of avatars, since the behavior you want when alt-zooming on avatars

+    // is almost always "tumble about middle" and not "spin around surface point"

+    {

+        LLVector3 obj_rel = original_focus_point - object->getRenderPosition();

+

+        //now that we have the object relative position, we should bias toward the center of the object

+        //based on the distance of the camera to the focus point vs. the distance of the camera to the focus

+

+        F32 relDist = llabs(obj_rel * LLViewerCamera::getInstance()->getAtAxis());

+        F32 viewDist = dist_vec(obj_pos + obj_rel, LLViewerCamera::getInstance()->getOrigin());

+

+

+        LLBBox obj_bbox = object->getBoundingBoxAgent();

+        F32 bias = 0.f;

+

+        // virtual_camera_pos is the camera position we are simulating by backing the camera off

+        // and adjusting the FOV

+        LLVector3 virtual_camera_pos = gAgent.getPosAgentFromGlobal(mFocusTargetGlobal + (getCameraPositionGlobal() - mFocusTargetGlobal) / (1.f + mCameraFOVZoomFactor));

+

+        // if the camera is inside the object (large, hollow objects, for example)

+        // leave focus point all the way to destination depth, away from object center

+        if(!obj_bbox.containsPointAgent(virtual_camera_pos))

+        {

+            // perform magic number biasing of focus point towards surface vs. planar center

+            bias = clamp_rescale(relDist/viewDist, 0.1f, 0.7f, 0.0f, 1.0f);

+            obj_rel = lerp(focus_offset_from_object_center, obj_rel, bias);

+        }

+

+        focus_offset_from_object_center = obj_rel;

+    }

+

+    return focus_offset_from_object_center;

+}

+

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

+// calcCameraMinDistance()

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

+bool LLAgentCamera::calcCameraMinDistance(F32 &obj_min_distance)

+{

+    bool soft_limit = false; // is the bounding box to be treated literally (volumes) or as an approximation (avatars)

+

+    if (!mFocusObject || mFocusObject->isDead() ||

+        mFocusObject->isMesh() ||

+        isDisableCameraConstraints())

+    {

+        obj_min_distance = 0.f;

+        return true;

+    }

+

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

+    {

+#ifdef LL_RELEASE_FOR_DOWNLOAD

+        LL_WARNS() << "Focus object with no drawable!" << LL_ENDL;

+#else

+        mFocusObject->dump();

+        LL_ERRS() << "Focus object with no drawable!" << LL_ENDL;

+#endif

+        obj_min_distance = 0.f;

+        return true;

+    }

+

+    LLQuaternion inv_object_rot = ~mFocusObject->getRenderRotation();

+    LLVector3 target_offset_origin = mFocusObjectOffset;

+    LLVector3 camera_offset_target(getCameraPositionAgent() - gAgent.getPosAgentFromGlobal(mFocusTargetGlobal));

+

+    // convert offsets into object local space

+    camera_offset_target.rotVec(inv_object_rot);

+    target_offset_origin.rotVec(inv_object_rot);

+

+    // push around object extents based on target offset

+    LLVector3 object_extents = mFocusObject->getScale();

+    if (mFocusObject->isAvatar())

+    {

+        // fudge factors that lets you zoom in on avatars a bit more (which don't do FOV zoom)

+        object_extents.mV[VX] *= AVATAR_ZOOM_MIN_X_FACTOR;

+        object_extents.mV[VY] *= AVATAR_ZOOM_MIN_Y_FACTOR;

+        object_extents.mV[VZ] *= AVATAR_ZOOM_MIN_Z_FACTOR;

+        soft_limit = true;

+    }

+    LLVector3 abs_target_offset = target_offset_origin;

+    abs_target_offset.abs();

+

+    LLVector3 target_offset_dir = target_offset_origin;

+

+    bool target_outside_object_extents = false;

+

+    for (U32 i = VX; i <= VZ; i++)

+    {

+        if (abs_target_offset.mV[i] * 2.f > object_extents.mV[i] + OBJECT_EXTENTS_PADDING)

+        {

+            target_outside_object_extents = true;

+        }

+        if (camera_offset_target.mV[i] > 0.f)

+        {

+            object_extents.mV[i] -= target_offset_origin.mV[i] * 2.f;

+        }

+        else

+        {

+            object_extents.mV[i] += target_offset_origin.mV[i] * 2.f;

+        }

+    }

+

+    // don't shrink the object extents so far that the object inverts

+    object_extents.clamp(0.001f, F32_MAX);

+

+    // move into first octant

+    LLVector3 camera_offset_target_abs_norm = camera_offset_target;

+    camera_offset_target_abs_norm.abs();

+    // make sure offset is non-zero

+    camera_offset_target_abs_norm.clamp(0.001f, F32_MAX);

+    camera_offset_target_abs_norm.normalize();

+

+    // find camera position relative to normalized object extents

+    LLVector3 camera_offset_target_scaled = camera_offset_target_abs_norm;

+    camera_offset_target_scaled.mV[VX] /= object_extents.mV[VX];

+    camera_offset_target_scaled.mV[VY] /= object_extents.mV[VY];

+    camera_offset_target_scaled.mV[VZ] /= object_extents.mV[VZ];

+

+    if (camera_offset_target_scaled.mV[VX] > camera_offset_target_scaled.mV[VY] &&

+        camera_offset_target_scaled.mV[VX] > camera_offset_target_scaled.mV[VZ])

+    {

+        if (camera_offset_target_abs_norm.mV[VX] < 0.001f)

+        {

+            obj_min_distance = object_extents.mV[VX] * 0.5f;

+        }

+        else

+        {

+            obj_min_distance = object_extents.mV[VX] * 0.5f / camera_offset_target_abs_norm.mV[VX];

+        }

+    }

+    else if (camera_offset_target_scaled.mV[VY] > camera_offset_target_scaled.mV[VZ])

+    {

+        if (camera_offset_target_abs_norm.mV[VY] < 0.001f)

+        {

+            obj_min_distance = object_extents.mV[VY] * 0.5f;

+        }

+        else

+        {

+            obj_min_distance = object_extents.mV[VY] * 0.5f / camera_offset_target_abs_norm.mV[VY];

+        }

+    }

+    else

+    {

+        if (camera_offset_target_abs_norm.mV[VZ] < 0.001f)

+        {

+            obj_min_distance = object_extents.mV[VZ] * 0.5f;

+        }

+        else

+        {

+            obj_min_distance = object_extents.mV[VZ] * 0.5f / camera_offset_target_abs_norm.mV[VZ];

+        }

+    }

+

+    LLVector3 object_split_axis;

+    LLVector3 target_offset_scaled = target_offset_origin;

+    target_offset_scaled.abs();

+    target_offset_scaled.normalize();

+    target_offset_scaled.mV[VX] /= object_extents.mV[VX];

+    target_offset_scaled.mV[VY] /= object_extents.mV[VY];

+    target_offset_scaled.mV[VZ] /= object_extents.mV[VZ];

+

+    if (target_offset_scaled.mV[VX] > target_offset_scaled.mV[VY] &&

+        target_offset_scaled.mV[VX] > target_offset_scaled.mV[VZ])

+    {

+        object_split_axis = LLVector3::x_axis;

+    }

+    else if (target_offset_scaled.mV[VY] > target_offset_scaled.mV[VZ])

+    {

+        object_split_axis = LLVector3::y_axis;

+    }

+    else

+    {

+        object_split_axis = LLVector3::z_axis;

+    }

+

+    LLVector3 camera_offset_object(getCameraPositionAgent() - mFocusObject->getPositionAgent());

+

+

+    F32 camera_offset_clip = camera_offset_object * object_split_axis;

+    F32 target_offset_clip = target_offset_dir * object_split_axis;

+

+    // target has moved outside of object extents

+    // check to see if camera and target are on same side

+    if (target_outside_object_extents)

+    {

+        if (camera_offset_clip > 0.f && target_offset_clip > 0.f)

+        {

+            return false;

+        }

+        else if (camera_offset_clip < 0.f && target_offset_clip < 0.f)

+        {

+            return false;

+        }

+    }

+

+    // clamp obj distance to diagonal of 10 by 10 cube

+    obj_min_distance = llmin(obj_min_distance, 10.f * F_SQRT3);

+

+    obj_min_distance += LLViewerCamera::getInstance()->getNear() + (soft_limit ? 0.1f : 0.2f);

+

+    return true;

+}

+

+F32 LLAgentCamera::getCameraZoomFraction(bool get_third_person)

+{

+    // 0.f -> camera zoomed all the way out

+    // 1.f -> camera zoomed all the way in

+    LLObjectSelectionHandle selection = LLSelectMgr::getInstance()->getSelection();

+    if (selection->getObjectCount() && selection->getSelectType() == SELECT_TYPE_HUD)

+    {

+        // already [0,1]

+        return mHUDTargetZoom;

+    }

+

+    if (get_third_person || (mFocusOnAvatar && cameraThirdPerson()))

+    {

+        return clamp_rescale(mCameraZoomFraction, MIN_ZOOM_FRACTION, MAX_ZOOM_FRACTION, 1.f, 0.f);

+    }

+

+    if (cameraCustomizeAvatar())

+    {

+        F32 distance = (F32)mCameraFocusOffsetTarget.magVec();

+        return clamp_rescale(distance, APPEARANCE_MIN_ZOOM, APPEARANCE_MAX_ZOOM, 1.f, 0.f );

+    }

+

+    F32 min_zoom;

+    F32 max_zoom = getCameraMaxZoomDistance();

+    if (isDisableCameraConstraints())

+    {

+        max_zoom = MAX_CAMERA_DISTANCE_FROM_OBJECT;

+    }

+

+    F32 distance = (F32)mCameraFocusOffsetTarget.magVec();

+    if (mFocusObject.notNull())

+    {

+        if (mFocusObject->isAvatar())

+        {

+            min_zoom = AVATAR_MIN_ZOOM;

+        }

+        else

+        {

+            min_zoom = OBJECT_MIN_ZOOM;

+        }

+    }

+    else

+    {

+        min_zoom = LAND_MIN_ZOOM;

+    }

+

+    return clamp_rescale(distance, min_zoom, max_zoom, 1.f, 0.f);

+}

+

+void LLAgentCamera::setCameraZoomFraction(F32 fraction)

+{

+    // 0.f -> camera zoomed all the way out

+    // 1.f -> camera zoomed all the way in

+    LLObjectSelectionHandle selection = LLSelectMgr::getInstance()->getSelection();

+

+    if (selection->getObjectCount() && selection->getSelectType() == SELECT_TYPE_HUD)

+    {

+        mHUDTargetZoom = fraction;

+    }

+    else if (mFocusOnAvatar && cameraThirdPerson())

+    {

+        mCameraZoomFraction = rescale(fraction, 0.f, 1.f, MAX_ZOOM_FRACTION, MIN_ZOOM_FRACTION);

+    }

+    else if (cameraCustomizeAvatar())

+    {

+        LLVector3d camera_offset_dir = mCameraFocusOffsetTarget;

+        camera_offset_dir.normalize();

+        mCameraFocusOffsetTarget = camera_offset_dir * rescale(fraction, 0.f, 1.f, APPEARANCE_MAX_ZOOM, APPEARANCE_MIN_ZOOM);

+    }

+    else

+    {

+        F32 min_zoom = LAND_MIN_ZOOM;

+        F32 max_zoom = getCameraMaxZoomDistance();

+        if (isDisableCameraConstraints())

+        {

+            max_zoom = MAX_CAMERA_DISTANCE_FROM_OBJECT;

+        }

+

+        if (mFocusObject.notNull())

+        {

+            if (mFocusObject.notNull())

+            {

+                if (mFocusObject->isAvatar())

+                {

+                    min_zoom = AVATAR_MIN_ZOOM;

+                }

+                else

+                {

+                    min_zoom = OBJECT_MIN_ZOOM;

+                }

+            }

+        }

+

+        LLVector3d camera_offset_dir = mCameraFocusOffsetTarget;

+        camera_offset_dir.normalize();

+        mCameraFocusOffsetTarget = camera_offset_dir * rescale(fraction, 0.f, 1.f, max_zoom, min_zoom);

+    }

+

+    startCameraAnimation();

+}

+

+F32 LLAgentCamera::getAgentHUDTargetZoom()

+{

+    static LLCachedControl<F32> hud_scale_factor(gSavedSettings, "HUDScaleFactor");

+    LLObjectSelectionHandle selection = LLSelectMgr::getInstance()->getSelection();

+    return (selection->getObjectCount() && selection->getSelectType() == SELECT_TYPE_HUD) ? hud_scale_factor*gAgentCamera.mHUDTargetZoom : hud_scale_factor;

+}

+

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

+// cameraOrbitAround()

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

+void LLAgentCamera::cameraOrbitAround(const F32 radians)

+{

+    LLObjectSelectionHandle selection = LLSelectMgr::getInstance()->getSelection();

+    if (selection->getObjectCount() && selection->getSelectType() == SELECT_TYPE_HUD)

+    {

+        // do nothing for hud selection

+    }

+    else if (mFocusOnAvatar && (mCameraMode == CAMERA_MODE_THIRD_PERSON || mCameraMode == CAMERA_MODE_FOLLOW))

+    {

+        gAgent.yaw(radians);

+    }

+    else

+    {

+        mOrbitAroundRadians += radians;

+        mCameraFocusOffsetTarget.rotVec(radians, 0.f, 0.f, 1.f);

+

+        cameraZoomIn(1.f);

+    }

+}

+

+

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

+// cameraOrbitOver()

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

+void LLAgentCamera::cameraOrbitOver(const F32 angle)

+{

+    LLObjectSelectionHandle selection = LLSelectMgr::getInstance()->getSelection();

+    if (selection->getObjectCount() && selection->getSelectType() == SELECT_TYPE_HUD)

+    {

+        // do nothing for hud selection

+    }

+    else if (mFocusOnAvatar && mCameraMode == CAMERA_MODE_THIRD_PERSON)

+    {

+        gAgent.pitch(angle);

+    }

+    else

+    {

+        LLVector3 camera_offset_unit(mCameraFocusOffsetTarget);

+        camera_offset_unit.normalize();

+

+        F32 angle_from_up = acos( camera_offset_unit * gAgent.getReferenceUpVector() );

+

+        LLVector3d left_axis;

+        left_axis.setVec(LLViewerCamera::getInstance()->getLeftAxis());

+        F32 new_angle = llclamp(angle_from_up - angle, 1.f * DEG_TO_RAD, 179.f * DEG_TO_RAD);

+        mOrbitOverAngle += angle_from_up - new_angle;

+        mCameraFocusOffsetTarget.rotVec(angle_from_up - new_angle, left_axis);

+

+        cameraZoomIn(1.f);

+    }

+}

+

+void LLAgentCamera::resetCameraOrbit()

+{

+    LLVector3 camera_offset_unit(mCameraFocusOffsetTarget);

+    camera_offset_unit.normalize();

+

+    LLVector3d left_axis;

+    left_axis.setVec(LLViewerCamera::getInstance()->getLeftAxis());

+    mCameraFocusOffsetTarget.rotVec(-mOrbitOverAngle, left_axis);

+

+    mCameraFocusOffsetTarget.rotVec(-mOrbitAroundRadians, 0.f, 0.f, 1.f);

+

+    cameraZoomIn(1.f);

+    resetOrbitDiff();

+}

+

+void LLAgentCamera::resetOrbitDiff()

+{

+    mOrbitAroundRadians = 0;

+    mOrbitOverAngle = 0;

+}

+

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

+// cameraZoomIn()

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

+void LLAgentCamera::cameraZoomIn(const F32 fraction)

+{

+    if (gDisconnected)

+    {

+        return;

+    }

+

+    LLObjectSelectionHandle selection = LLSelectMgr::getInstance()->getSelection();

+    if (LLToolMgr::getInstance()->inBuildMode() && selection->getObjectCount() && selection->getSelectType() == SELECT_TYPE_HUD)

+    {

+        // just update hud zoom level

+        mHUDTargetZoom /= fraction;

+        return;

+    }

+

+    LLVector3d camera_offset_unit(mCameraFocusOffsetTarget);

+    F32 current_distance = (F32)camera_offset_unit.normalize();

+    F32 new_distance = current_distance * fraction;

+

+    // Unless camera is unlocked

+    if (!isDisableCameraConstraints())

+    {

+        F32 min_zoom = LAND_MIN_ZOOM;

+

+        // Don't move through focus point

+        if (mFocusObject)

+        {

+            LLVector3 camera_offset_dir((F32)camera_offset_unit.mdV[VX], (F32)camera_offset_unit.mdV[VY], (F32)camera_offset_unit.mdV[VZ]);

+

+            if (mFocusObject->isAvatar())

+            {

+                calcCameraMinDistance(min_zoom);

+            }

+            else

+            {

+                min_zoom = OBJECT_MIN_ZOOM;

+            }

+        }

+

+        new_distance = llmax(new_distance, min_zoom);

+

+        F32 max_distance = getCameraMaxZoomDistance();

+        max_distance = llmin(max_distance, current_distance * 4.f); //Scaled max relative to current distance.  MAINT-3154

+        new_distance = llmin(new_distance, max_distance);

+

+        if (cameraCustomizeAvatar())

+        {

+            new_distance = llclamp(new_distance, APPEARANCE_MIN_ZOOM, APPEARANCE_MAX_ZOOM);

+        }

+    }

+

+    mCameraFocusOffsetTarget = new_distance * camera_offset_unit;

+}

+

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

+// cameraOrbitIn()

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

+void LLAgentCamera::cameraOrbitIn(const F32 meters)

+{

+    if (mFocusOnAvatar && mCameraMode == CAMERA_MODE_THIRD_PERSON)

+    {

+        F32 camera_offset_dist = llmax(0.001f, getCameraOffsetInitial().magVec() * gSavedSettings.getF32("CameraOffsetScale"));

+

+        mCameraZoomFraction = (mTargetCameraDistance - meters) / camera_offset_dist;

+

+        if (!gSavedSettings.getBOOL("FreezeTime") && mCameraZoomFraction < MIN_ZOOM_FRACTION && meters > 0.f)

+        {

+            // No need to animate, camera is already there.

+            changeCameraToMouselook(false);

+        }

+

+        if (!isDisableCameraConstraints())

+        {

+            mCameraZoomFraction = llclamp(mCameraZoomFraction, MIN_ZOOM_FRACTION, MAX_ZOOM_FRACTION);

+        }

+    }

+    else

+    {

+        LLVector3d  camera_offset_unit(mCameraFocusOffsetTarget);

+        F32 current_distance = (F32)camera_offset_unit.normalize();

+        F32 new_distance = current_distance - meters;

+

+        // Unless camera is unlocked

+        if (!isDisableCameraConstraints())

+        {

+            F32 min_zoom = LAND_MIN_ZOOM;

+

+            // Don't move through focus point

+            if (mFocusObject.notNull())

+            {

+                if (mFocusObject->isAvatar())

+                {

+                    min_zoom = AVATAR_MIN_ZOOM;

+                }

+                else

+                {

+                    min_zoom = OBJECT_MIN_ZOOM;

+                }

+            }

+

+            new_distance = llmax(new_distance, min_zoom);

+

+            F32 max_distance = getCameraMaxZoomDistance();

+            new_distance = llmin(new_distance, max_distance);

+

+            if (CAMERA_MODE_CUSTOMIZE_AVATAR == getCameraMode())

+            {

+                new_distance = llclamp(new_distance, APPEARANCE_MIN_ZOOM, APPEARANCE_MAX_ZOOM);

+            }

+        }

+

+        // Compute new camera offset

+        mCameraFocusOffsetTarget = new_distance * camera_offset_unit;

+        cameraZoomIn(1.f);

+    }

+}

+

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

+// cameraPanIn()

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

+void LLAgentCamera::cameraPanIn(F32 meters)

+{

+    LLVector3d at_axis;

+    at_axis.setVec(LLViewerCamera::getInstance()->getAtAxis());

+

+    mPanFocusDiff += meters * at_axis;

+

+    mFocusTargetGlobal += meters * at_axis;

+    mFocusGlobal = mFocusTargetGlobal;

+    // don't enforce zoom constraints as this is the only way for users to get past them easily

+    updateFocusOffset();

+    // NOTE: panning movements expect the camera to move exactly with the focus target, not animated behind -Nyx

+    mCameraSmoothingLastPositionGlobal = calcCameraPositionTargetGlobal();

+}

+

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

+// cameraPanLeft()

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

+void LLAgentCamera::cameraPanLeft(F32 meters)

+{

+    LLVector3d left_axis;

+    left_axis.setVec(LLViewerCamera::getInstance()->getLeftAxis());

+

+    mPanFocusDiff += meters * left_axis;

+

+    mFocusTargetGlobal += meters * left_axis;

+    mFocusGlobal = mFocusTargetGlobal;

+

+    // disable smoothing for camera pan, which causes some residents unhappiness

+    mCameraSmoothingStop = true;

+

+    cameraZoomIn(1.f);

+    updateFocusOffset();

+    // NOTE: panning movements expect the camera to move exactly with the focus target, not animated behind - Nyx

+    mCameraSmoothingLastPositionGlobal = calcCameraPositionTargetGlobal();

+}

+

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

+// cameraPanUp()

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

+void LLAgentCamera::cameraPanUp(F32 meters)

+{

+    LLVector3d up_axis;

+    up_axis.setVec(LLViewerCamera::getInstance()->getUpAxis());

+

+    mPanFocusDiff += meters * up_axis;

+

+    mFocusTargetGlobal += meters * up_axis;

+    mFocusGlobal = mFocusTargetGlobal;

+

+    // disable smoothing for camera pan, which causes some residents unhappiness

+    mCameraSmoothingStop = true;

+

+    cameraZoomIn(1.f);

+    updateFocusOffset();

+    // NOTE: panning movements expect the camera to move exactly with the focus target, not animated behind -Nyx

+    mCameraSmoothingLastPositionGlobal = calcCameraPositionTargetGlobal();

+}

+

+void LLAgentCamera::resetCameraPan()

+{

+    mFocusTargetGlobal -= mPanFocusDiff;

+

+    mFocusGlobal = mFocusTargetGlobal;

+    mCameraSmoothingStop = true;

+

+    cameraZoomIn(1.f);

+    updateFocusOffset();

+

+    mCameraSmoothingLastPositionGlobal = calcCameraPositionTargetGlobal();

+

+    resetPanDiff();

+}

+

+void LLAgentCamera::resetPanDiff()

+{

+    mPanFocusDiff.clear();

+}

+

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

+// updateLookAt()

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

+void LLAgentCamera::updateLookAt(const S32 mouse_x, const S32 mouse_y)

+{

+    static LLVector3 last_at_axis;

+

+    if (!isAgentAvatarValid()) return;

+

+    LLQuaternion av_inv_rot = ~gAgentAvatarp->mRoot->getWorldRotation();

+    LLVector3 root_at = LLVector3::x_axis * gAgentAvatarp->mRoot->getWorldRotation();

+

+    if  (LLTrace::get_frame_recording().getLastRecording().getLastValue(*gViewerWindow->getMouseVelocityStat()) < 0.01f

+        && (root_at * last_at_axis > 0.95f))

+    {

+        LLVector3 vel = gAgentAvatarp->getVelocity();

+        if (vel.magVecSquared() > 4.f)

+        {

+            setLookAt(LOOKAT_TARGET_IDLE, gAgentAvatarp, vel * av_inv_rot);

+        }

+        else

+        {

+            // *FIX: rotate mframeagent by sit object's rotation?

+            LLQuaternion look_rotation = gAgentAvatarp->isSitting() ? gAgentAvatarp->getRenderRotation() : gAgent.getFrameAgent().getQuaternion(); // use camera's current rotation

+            LLVector3 look_offset = LLVector3(2.f, 0.f, 0.f) * look_rotation * av_inv_rot;

+            setLookAt(LOOKAT_TARGET_IDLE, gAgentAvatarp, look_offset);

+        }

+        last_at_axis = root_at;

+        return;

+    }

+

+    last_at_axis = root_at;

+

+    if (CAMERA_MODE_CUSTOMIZE_AVATAR == getCameraMode())

+    {

+        setLookAt(LOOKAT_TARGET_NONE, gAgentAvatarp, LLVector3(-2.f, 0.f, 0.f));

+    }

+    else

+    {

+        // Move head based on cursor position

+        ELookAtType lookAtType = LOOKAT_TARGET_NONE;

+        LLVector3 headLookAxis;

+        LLCoordFrame frameCamera = *((LLCoordFrame*)LLViewerCamera::getInstance());

+

+        if (cameraMouselook())

+        {

+            lookAtType = LOOKAT_TARGET_MOUSELOOK;

+        }

+        else if (cameraThirdPerson())

+        {

+            // range from -.5 to .5

+            F32 x_from_center =

+                ((F32) mouse_x / (F32) gViewerWindow->getWorldViewWidthScaled() ) - 0.5f;

+            F32 y_from_center =

+                ((F32) mouse_y / (F32) gViewerWindow->getWorldViewHeightScaled() ) - 0.5f;

+

+            frameCamera.yaw( - x_from_center * gSavedSettings.getF32("YawFromMousePosition") * DEG_TO_RAD);

+            frameCamera.pitch( - y_from_center * gSavedSettings.getF32("PitchFromMousePosition") * DEG_TO_RAD);

+            lookAtType = LOOKAT_TARGET_FREELOOK;

+        }

+

+        headLookAxis = frameCamera.getAtAxis();

+        // RN: we use world-space offset for mouselook and freelook

+        //headLookAxis = headLookAxis * av_inv_rot;

+        setLookAt(lookAtType, gAgentAvatarp, headLookAxis);

+    }

+}

+

+static LLTrace::BlockTimerStatHandle FTM_UPDATE_CAMERA("Camera");

+

+extern bool gCubeSnapshot;

+

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

+// updateCamera()

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

+void LLAgentCamera::updateCamera()

+{

+    LL_RECORD_BLOCK_TIME(FTM_UPDATE_CAMERA);

+    if (gCubeSnapshot)

+    {

+        return;

+    }

+

+    // - changed camera_skyward to the new global "mCameraUpVector"

+    mCameraUpVector = LLVector3::z_axis;

+    //LLVector3 camera_skyward(0.f, 0.f, 1.f);

+

+    U32 camera_mode = mCameraAnimating ? mLastCameraMode : mCameraMode;

+

+    validateFocusObject();

+

+    if (isAgentAvatarValid() &&

+        gAgentAvatarp->isSitting() &&

+        camera_mode == CAMERA_MODE_MOUSELOOK)

+    {

+        //changed camera_skyward to the new global "mCameraUpVector"

+        mCameraUpVector = mCameraUpVector * gAgentAvatarp->getRenderRotation();

+    }

+

+    if (cameraThirdPerson() && (mFocusOnAvatar || mAllowChangeToFollow) && LLFollowCamMgr::getInstance()->getActiveFollowCamParams())

+    {

+        mAllowChangeToFollow = false;

+        mFocusOnAvatar = true;

+        changeCameraToFollow();

+    }

+

+    //NOTE - this needs to be integrated into a general upVector system here within llAgent.

+    if ( camera_mode == CAMERA_MODE_FOLLOW && mFocusOnAvatar )

+    {

+        mCameraUpVector = mFollowCam.getUpVector();

+    }

+

+    if (mSitCameraEnabled)

+    {

+        if (mSitCameraReferenceObject->isDead())

+        {

+            setSitCamera(LLUUID::null);

+        }

+    }

+

+    // Update UI with our camera inputs

+    LLFloaterCamera* camera_floater = LLFloaterReg::findTypedInstance<LLFloaterCamera>("camera");

+    if (camera_floater)

+    {

+        camera_floater->mRotate->setToggleState(gAgentCamera.getOrbitRightKey() > 0.f,  // left

+                                                gAgentCamera.getOrbitUpKey() > 0.f,     // top

+                                                gAgentCamera.getOrbitLeftKey() > 0.f,   // right

+                                                gAgentCamera.getOrbitDownKey() > 0.f);  // bottom

+

+        camera_floater->mTrack->setToggleState(gAgentCamera.getPanLeftKey() > 0.f,      // left

+                                               gAgentCamera.getPanUpKey() > 0.f,            // top

+                                               gAgentCamera.getPanRightKey() > 0.f,     // right

+                                               gAgentCamera.getPanDownKey() > 0.f);     // bottom

+    }

+

+    // Handle camera movement based on keyboard.

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

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

+    const F32 PAN_RATE = 5.f;                               // meters per second

+

+    if (gAgentCamera.getOrbitUpKey() || gAgentCamera.getOrbitDownKey())

+    {

+        F32 input_rate = gAgentCamera.getOrbitUpKey() - gAgentCamera.getOrbitDownKey();

+        cameraOrbitOver( input_rate * ORBIT_OVER_RATE / gFPSClamped );

+    }

+

+    if (gAgentCamera.getOrbitLeftKey() || gAgentCamera.getOrbitRightKey())

+    {

+        F32 input_rate = gAgentCamera.getOrbitLeftKey() - gAgentCamera.getOrbitRightKey();

+        cameraOrbitAround(input_rate * ORBIT_AROUND_RATE / gFPSClamped);

+    }

+

+    if (gAgentCamera.getOrbitInKey() || gAgentCamera.getOrbitOutKey())

+    {

+        F32 input_rate = gAgentCamera.getOrbitInKey() - gAgentCamera.getOrbitOutKey();

+

+        LLVector3d to_focus = gAgent.getPosGlobalFromAgent(LLViewerCamera::getInstance()->getOrigin()) - calcFocusPositionTargetGlobal();

+        F32 distance_to_focus = (F32)to_focus.magVec();

+        // Move at distance (in meters) meters per second

+        cameraOrbitIn( input_rate * distance_to_focus / gFPSClamped );

+    }

+

+    if (gAgentCamera.getPanInKey() || gAgentCamera.getPanOutKey())

+    {

+        F32 input_rate = gAgentCamera.getPanInKey() - gAgentCamera.getPanOutKey();

+        cameraPanIn(input_rate * PAN_RATE / gFPSClamped);

+    }

+

+    if (gAgentCamera.getPanRightKey() || gAgentCamera.getPanLeftKey())

+    {

+        F32 input_rate = gAgentCamera.getPanRightKey() - gAgentCamera.getPanLeftKey();

+        cameraPanLeft(input_rate * -PAN_RATE / gFPSClamped );

+    }

+

+    if (gAgentCamera.getPanUpKey() || gAgentCamera.getPanDownKey())

+    {

+        F32 input_rate = gAgentCamera.getPanUpKey() - gAgentCamera.getPanDownKey();

+        cameraPanUp(input_rate * PAN_RATE / gFPSClamped );

+    }

+

+    // Clear camera keyboard keys.

+    gAgentCamera.clearOrbitKeys();

+    gAgentCamera.clearPanKeys();

+

+    // lerp camera focus offset

+    mCameraFocusOffset = lerp(mCameraFocusOffset, mCameraFocusOffsetTarget, LLSmoothInterpolation::getInterpolant(CAMERA_FOCUS_HALF_LIFE));

+

+    if ( mCameraMode == CAMERA_MODE_FOLLOW )

+    {

+        if (isAgentAvatarValid())

+        {

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

+            // this is where the avatar's position and rotation are given to followCam, and

+            // where it is updated. All three of its attributes are updated: (1) position,

+            // (2) focus, and (3) upvector. They can then be queried elsewhere in llAgent.

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

+            // *TODO: use combined rotation of frameagent and sit object

+            LLQuaternion avatarRotationForFollowCam = gAgentAvatarp->isSitting() ? gAgentAvatarp->getRenderRotation() : gAgent.getFrameAgent().getQuaternion();

+

+            LLFollowCamParams* current_cam = LLFollowCamMgr::getInstance()->getActiveFollowCamParams();

+            if (current_cam)

+            {

+                mFollowCam.copyParams(*current_cam);

+                mFollowCam.setSubjectPositionAndRotation( gAgentAvatarp->getRenderPosition(), avatarRotationForFollowCam );

+                mFollowCam.update();

+                LLViewerJoystick::getInstance()->setCameraNeedsUpdate(true);

+            }

+            else

+            {

+                changeCameraToThirdPerson(true);

+            }

+        }

+    }

+

+    bool hit_limit;

+    LLVector3d camera_pos_global;

+    LLVector3d camera_target_global = calcCameraPositionTargetGlobal(&hit_limit);

+    mCameraVirtualPositionAgent = gAgent.getPosAgentFromGlobal(camera_target_global);

+    LLVector3d focus_target_global = calcFocusPositionTargetGlobal();

+

+    // perform field of view correction

+    mCameraFOVZoomFactor = calcCameraFOVZoomFactor();

+    camera_target_global = focus_target_global + (camera_target_global - focus_target_global) * (1.f + mCameraFOVZoomFactor);

+

+    gAgent.setShowAvatar(true); // can see avatar by default

+

+    // Adjust position for animation

+    if (mCameraAnimating)

+    {

+        F32 time = mAnimationTimer.getElapsedTimeF32();

+

+        // yet another instance of critically damped motion, hooray!

+        // F32 fraction_of_animation = 1.f - pow(2.f, -time / CAMERA_ZOOM_HALF_LIFE);

+

+        // linear interpolation

+        F32 fraction_of_animation = time / mAnimationDuration;

+

+        bool isfirstPerson = mCameraMode == CAMERA_MODE_MOUSELOOK;

+        bool wasfirstPerson = mLastCameraMode == CAMERA_MODE_MOUSELOOK;

+        F32 fraction_animation_to_skip;

+

+        if (mAnimationCameraStartGlobal == camera_target_global)

+        {

+            fraction_animation_to_skip = 0.f;

+        }

+        else

+        {

+            LLVector3d cam_delta = mAnimationCameraStartGlobal - camera_target_global;

+            fraction_animation_to_skip = HEAD_BUFFER_SIZE / (F32)cam_delta.magVec();

+        }

+        F32 animation_start_fraction = (wasfirstPerson) ? fraction_animation_to_skip : 0.f;

+        F32 animation_finish_fraction =  (isfirstPerson) ? (1.f - fraction_animation_to_skip) : 1.f;

+

+        if (fraction_of_animation < animation_finish_fraction)

+        {

+            if (fraction_of_animation < animation_start_fraction || fraction_of_animation > animation_finish_fraction )

+            {

+                gAgent.setShowAvatar(false);

+            }

+

+            // ...adjust position for animation

+            F32 smooth_fraction_of_animation = llsmoothstep(0.0f, 1.0f, fraction_of_animation);

+            camera_pos_global = lerp(mAnimationCameraStartGlobal, camera_target_global, smooth_fraction_of_animation);

+            mFocusGlobal = lerp(mAnimationFocusStartGlobal, focus_target_global, smooth_fraction_of_animation);

+        }

+        else

+        {

+            // ...animation complete

+            mCameraAnimating = false;

+

+            camera_pos_global = camera_target_global;

+            mFocusGlobal = focus_target_global;

+

+            gAgent.endAnimationUpdateUI();

+            gAgent.setShowAvatar(true);

+        }

+

+        if (isAgentAvatarValid() && (mCameraMode != CAMERA_MODE_MOUSELOOK))

+        {

+            gAgentAvatarp->updateAttachmentVisibility(mCameraMode);

+        }

+    }

+    else

+    {

+        camera_pos_global = camera_target_global;

+        mFocusGlobal = focus_target_global;

+        gAgent.setShowAvatar(true);

+    }

+

+    // smoothing

+    if (true)

+    {

+        LLVector3d agent_pos = gAgent.getPositionGlobal();

+        LLVector3d camera_pos_agent = camera_pos_global - agent_pos;

+        // Sitting on what you're manipulating can cause camera jitter with smoothing.

+        // This turns off smoothing while editing. -MG

+        bool in_build_mode = LLToolMgr::getInstance()->inBuildMode();

+        mCameraSmoothingStop = mCameraSmoothingStop || in_build_mode;

+

+        if (cameraThirdPerson() && !mCameraSmoothingStop)

+        {

+            const F32 SMOOTHING_HALF_LIFE = 0.02f;

+

+            F32 smoothing = LLSmoothInterpolation::getInterpolant(gSavedSettings.getF32("CameraPositionSmoothing") * SMOOTHING_HALF_LIFE, false);

+

+            if (mFocusOnAvatar && !mFocusObject) // we differentiate on avatar mode

+            {

+                // for avatar-relative focus, we smooth in avatar space -

+                // the avatar moves too jerkily w/r/t global space to smooth there.

+

+                LLVector3d delta = camera_pos_agent - mCameraSmoothingLastPositionAgent;

+                if (delta.magVec() < MAX_CAMERA_SMOOTH_DISTANCE)  // only smooth over short distances please

+                {

+                    camera_pos_agent = lerp(mCameraSmoothingLastPositionAgent, camera_pos_agent, smoothing);

+                    camera_pos_global = camera_pos_agent + agent_pos;

+                }

+            }

+            else

+            {

+                LLVector3d delta = camera_pos_global - mCameraSmoothingLastPositionGlobal;

+                if (delta.magVec() < MAX_CAMERA_SMOOTH_DISTANCE) // only smooth over short distances please

+                {

+                    camera_pos_global = lerp(mCameraSmoothingLastPositionGlobal, camera_pos_global, smoothing);

+                }

+            }

+        }

+

+        mCameraSmoothingLastPositionGlobal = camera_pos_global;

+        mCameraSmoothingLastPositionAgent = camera_pos_agent;

+        mCameraSmoothingStop = false;

+    }

+

+

+    mCameraCurrentFOVZoomFactor = lerp(mCameraCurrentFOVZoomFactor, mCameraFOVZoomFactor, LLSmoothInterpolation::getInterpolant(FOV_ZOOM_HALF_LIFE));

+

+//  LL_INFOS() << "Current FOV Zoom: " << mCameraCurrentFOVZoomFactor << " Target FOV Zoom: " << mCameraFOVZoomFactor << " Object penetration: " << mFocusObjectDist << LL_ENDL;

+

+    LLVector3 focus_agent = gAgent.getPosAgentFromGlobal(mFocusGlobal);

+

+    mCameraPositionAgent = gAgent.getPosAgentFromGlobal(camera_pos_global);

+

+    // Move the camera

+

+    LLViewerCamera::getInstance()->updateCameraLocation(mCameraPositionAgent, mCameraUpVector, focus_agent);

+    //LLViewerCamera::getInstance()->updateCameraLocation(mCameraPositionAgent, camera_skyward, focus_agent);

+

+    // Change FOV

+    LLViewerCamera::getInstance()->setView(LLViewerCamera::getInstance()->getDefaultFOV() / (1.f + mCameraCurrentFOVZoomFactor));

+

+    // follow camera when in customize mode

+    if (cameraCustomizeAvatar())

+    {

+        setLookAt(LOOKAT_TARGET_FOCUS, NULL, mCameraPositionAgent);

+    }

+

+    // update the travel distance stat

+    // this isn't directly related to the camera

+    // but this seemed like the best place to do this

+    LLVector3d global_pos = gAgent.getPositionGlobal();

+    if (!gAgent.getLastPositionGlobal().isExactlyZero())

+    {

+        LLVector3d delta = global_pos - gAgent.getLastPositionGlobal();

+        gAgent.setDistanceTraveled(gAgent.getDistanceTraveled() + delta.magVec());

+    }

+    gAgent.setLastPositionGlobal(global_pos);

+

+    if (LLVOAvatar::sVisibleInFirstPerson && isAgentAvatarValid() && !gAgentAvatarp->isSitting() && cameraMouselook())

+    {

+        LLVector3 head_pos = gAgentAvatarp->mHeadp->getWorldPosition() +

+            LLVector3(0.08f, 0.f, 0.05f) * gAgentAvatarp->mHeadp->getWorldRotation() +

+            LLVector3(0.1f, 0.f, 0.f) * gAgentAvatarp->mPelvisp->getWorldRotation();

+        LLVector3 diff = mCameraPositionAgent - head_pos;

+        diff = diff * ~gAgentAvatarp->mRoot->getWorldRotation();

+

+        LLJoint* torso_joint = gAgentAvatarp->mTorsop;

+        LLJoint* chest_joint = gAgentAvatarp->mChestp;

+        LLVector3 torso_scale = torso_joint->getScale();

+        LLVector3 chest_scale = chest_joint->getScale();

+

+        // shorten avatar skeleton to avoid foot interpenetration

+        if (!gAgentAvatarp->mInAir)

+        {

+            LLVector3 chest_offset = LLVector3(0.f, 0.f, chest_joint->getPosition().mV[VZ]) * torso_joint->getWorldRotation();

+            F32 z_compensate = llclamp(-diff.mV[VZ], -0.2f, 1.f);

+            F32 scale_factor = llclamp(1.f - ((z_compensate * 0.5f) / chest_offset.mV[VZ]), 0.5f, 1.2f);

+            torso_joint->setScale(LLVector3(1.f, 1.f, scale_factor));

+

+            LLJoint* neck_joint = gAgentAvatarp->mNeckp;

+            LLVector3 neck_offset = LLVector3(0.f, 0.f, neck_joint->getPosition().mV[VZ]) * chest_joint->getWorldRotation();

+            scale_factor = llclamp(1.f - ((z_compensate * 0.5f) / neck_offset.mV[VZ]), 0.5f, 1.2f);

+            chest_joint->setScale(LLVector3(1.f, 1.f, scale_factor));

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

+        }

+

+        // SL-315

+        gAgentAvatarp->mPelvisp->setPosition(gAgentAvatarp->mPelvisp->getPosition() + diff);

+

+        gAgentAvatarp->mRoot->updateWorldMatrixChildren();

+

+        for (LLVOAvatar::attachment_map_t::iterator iter = gAgentAvatarp->mAttachmentPoints.begin();

+             iter != gAgentAvatarp->mAttachmentPoints.end(); )

+        {

+            LLVOAvatar::attachment_map_t::iterator curiter = iter++;

+            LLViewerJointAttachment* attachment = curiter->second;

+            for (LLViewerJointAttachment::attachedobjs_vec_t::iterator attachment_iter = attachment->mAttachedObjects.begin();

+                 attachment_iter != attachment->mAttachedObjects.end();

+                 ++attachment_iter)

+            {

+                LLViewerObject *attached_object = attachment_iter->get();

+                if (attached_object && !attached_object->isDead() && attached_object->mDrawable.notNull())

+                {

+                    // clear any existing "early" movements of attachment

+                    attached_object->mDrawable->clearState(LLDrawable::EARLY_MOVE);

+                    gPipeline.updateMoveNormalAsync(attached_object->mDrawable);

+                    attached_object->updateText();

+                }

+            }

+        }

+

+        torso_joint->setScale(torso_scale);

+        chest_joint->setScale(chest_scale);

+    }

+}

+

+void LLAgentCamera::updateLastCamera()

+{

+    mLastCameraMode = mCameraMode;

+}

+

+void LLAgentCamera::updateFocusOffset()

+{

+    validateFocusObject();

+    if (mFocusObject.notNull())

+    {

+        LLVector3d obj_pos = gAgent.getPosGlobalFromAgent(mFocusObject->getRenderPosition());

+        mFocusObjectOffset.setVec(mFocusTargetGlobal - obj_pos);

+    }

+}

+

+void LLAgentCamera::validateFocusObject()

+{

+    if (mFocusObject.notNull() &&

+        mFocusObject->isDead())

+    {

+        mFocusObjectOffset.clearVec();

+        clearFocusObject();

+        mCameraFOVZoomFactor = 0.f;

+    }

+}

+

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

+// calcFocusPositionTargetGlobal()

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

+LLVector3d LLAgentCamera::calcFocusPositionTargetGlobal()

+{

+    if (mFocusObject.notNull() && mFocusObject->isDead())

+    {

+        clearFocusObject();

+    }

+

+    if (mCameraMode == CAMERA_MODE_FOLLOW && mFocusOnAvatar)

+    {

+        mFocusTargetGlobal = gAgent.getPosGlobalFromAgent(mFollowCam.getSimulatedFocus());

+        return mFocusTargetGlobal;

+    }

+    else if (mCameraMode == CAMERA_MODE_MOUSELOOK)

+    {

+        LLVector3d at_axis(1.0, 0.0, 0.0);

+        LLQuaternion agent_rot = gAgent.getFrameAgent().getQuaternion();

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

+        {

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

+            if (!root_object->flagCameraDecoupled())

+            {

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

+            }

+        }

+        at_axis = at_axis * agent_rot;

+        mFocusTargetGlobal = calcCameraPositionTargetGlobal() + at_axis;

+        return mFocusTargetGlobal;

+    }

+    else if (mCameraMode == CAMERA_MODE_CUSTOMIZE_AVATAR)

+    {

+        if (mFocusOnAvatar)

+        {

+            LLVector3 focus_target = isAgentAvatarValid()

+                ? gAgentAvatarp->mHeadp->getWorldPosition()

+                : gAgent.getPositionAgent();

+            LLVector3d focus_target_global = gAgent.getPosGlobalFromAgent(focus_target);

+            mFocusTargetGlobal = focus_target_global;

+        }

+        return mFocusTargetGlobal;

+    }

+    else if (!mFocusOnAvatar)

+    {

+        if (mFocusObject.notNull() && !mFocusObject->isDead() && mFocusObject->mDrawable.notNull())

+        {

+            LLDrawable* drawablep = mFocusObject->mDrawable;

+

+            if (mTrackFocusObject &&

+                drawablep &&

+                drawablep->isActive())

+            {

+                if (!mFocusObject->isAvatar())

+                {

+                    if (mFocusObject->isSelected())

+                    {

+                        gPipeline.updateMoveNormalAsync(drawablep);

+                    }

+                    else

+                    {

+                        if (drawablep->isState(LLDrawable::MOVE_UNDAMPED))

+                        {

+                            gPipeline.updateMoveNormalAsync(drawablep);

+                        }

+                        else

+                        {

+                            gPipeline.updateMoveDampedAsync(drawablep);

+                        }

+                    }

+                }

+            }

+            // if not tracking object, update offset based on new object position

+            else

+            {

+                updateFocusOffset();

+            }

+            LLVector3 focus_agent = mFocusObject->getRenderPosition() + mFocusObjectOffset;

+            mFocusTargetGlobal.setVec(gAgent.getPosGlobalFromAgent(focus_agent));

+        }

+        return mFocusTargetGlobal;

+    }

+    else if (mSitCameraEnabled && isAgentAvatarValid() && gAgentAvatarp->isSitting() && mSitCameraReferenceObject.notNull())

+    {

+        // sit camera

+        LLVector3 object_pos = mSitCameraReferenceObject->getRenderPosition();

+        LLQuaternion object_rot = mSitCameraReferenceObject->getRenderRotation();

+

+        LLVector3 target_pos = object_pos + (mSitCameraFocus * object_rot);

+        return gAgent.getPosGlobalFromAgent(target_pos);

+    }

+    else

+    {

+        return gAgent.getPositionGlobal() + calcThirdPersonFocusOffset();

+    }

+}

+

+LLVector3d LLAgentCamera::calcThirdPersonFocusOffset()

+{

+    // ...offset from avatar

+    LLVector3d focus_offset;

+    LLQuaternion agent_rot = gAgent.getFrameAgent().getQuaternion();

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

+    {

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

+    }

+

+    static LLCachedControl<LLVector3d> focus_offset_initial(gSavedSettings, "FocusOffsetRearView", LLVector3d());

+    return focus_offset_initial * agent_rot;

+}

+

+void LLAgentCamera::setupSitCamera()

+{

+    // agent frame entering this function is in world coordinates

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

+    {

+        LLQuaternion parent_rot = ((LLViewerObject*)gAgentAvatarp->getParent())->getRenderRotation();

+        // slam agent coordinate frame to proper parent local version

+        LLVector3 at_axis = gAgent.getFrameAgent().getAtAxis();

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

+        at_axis.normalize();

+        gAgent.resetAxes(at_axis * ~parent_rot);

+    }

+}

+

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

+// getCameraPositionAgent()

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

+const LLVector3 &LLAgentCamera::getCameraPositionAgent() const

+{

+    return LLViewerCamera::getInstance()->getOrigin();

+}

+

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

+// getCameraPositionGlobal()

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

+LLVector3d LLAgentCamera::getCameraPositionGlobal() const

+{

+    return gAgent.getPosGlobalFromAgent(LLViewerCamera::getInstance()->getOrigin());

+}

+

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

+// calcCameraFOVZoomFactor()

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

+F32 LLAgentCamera::calcCameraFOVZoomFactor()

+{

+    LLVector3 camera_offset_dir;

+    camera_offset_dir.setVec(mCameraFocusOffset);

+

+    if (mCameraMode == CAMERA_MODE_MOUSELOOK)

+    {

+        return 0.f;

+    }

+    else if (mFocusObject.notNull() && !mFocusObject->isAvatar() && !mFocusOnAvatar)

+    {

+        // don't FOV zoom on mostly transparent objects

+        F32 obj_min_dist = 0.f;

+        calcCameraMinDistance(obj_min_dist);

+        F32 current_distance = llmax(0.001f, camera_offset_dir.magVec());

+

+        mFocusObjectDist = obj_min_dist - current_distance;

+

+        F32 new_fov_zoom = llclamp(mFocusObjectDist / current_distance, 0.f, 1000.f);

+        return new_fov_zoom;

+    }

+    else // focusing on land or avatar

+    {

+        // keep old field of view until user changes focus explicitly

+        return mCameraFOVZoomFactor;

+        //return 0.f;

+    }

+}

+

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

+// calcCameraPositionTargetGlobal()

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

+LLVector3d LLAgentCamera::calcCameraPositionTargetGlobal(bool *hit_limit)

+{

+    // Compute base camera position and look-at points.

+    F32         camera_land_height;

+    LLVector3d  frame_center_global = !isAgentAvatarValid() ?

+        gAgent.getPositionGlobal() :

+        gAgent.getPosGlobalFromAgent(getAvatarRootPosition());

+

+    bool        isConstrained = false;

+    LLVector3d  head_offset;

+    head_offset.setVec(mThirdPersonHeadOffset);

+

+    LLVector3d camera_position_global;

+

+    if (mCameraMode == CAMERA_MODE_FOLLOW && mFocusOnAvatar)

+    {

+        camera_position_global = gAgent.getPosGlobalFromAgent(mFollowCam.getSimulatedPosition());

+    }

+    else if (mCameraMode == CAMERA_MODE_MOUSELOOK)

+    {

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

+        {

+            LL_WARNS() << "Null avatar drawable!" << LL_ENDL;

+            return LLVector3d::zero;

+        }

+

+        head_offset.clearVec();

+        F32 fixup;

+        if (gAgentAvatarp->hasPelvisFixup(fixup) && !gAgentAvatarp->isSitting())

+        {

+            head_offset[VZ] -= fixup;

+        }

+        if (gAgentAvatarp->isSitting())

+        {

+            head_offset.mdV[VZ] += 0.1;

+        }

+

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

+        {

+            gAgentAvatarp->updateHeadOffset();

+            head_offset.mdV[VX] += gAgentAvatarp->mHeadOffset.mV[VX];

+            head_offset.mdV[VY] += gAgentAvatarp->mHeadOffset.mV[VY];

+            head_offset.mdV[VZ] += gAgentAvatarp->mHeadOffset.mV[VZ];

+            const LLMatrix4& mat = ((LLViewerObject*) gAgentAvatarp->getParent())->getRenderMatrix();

+            camera_position_global = gAgent.getPosGlobalFromAgent

+                                ((gAgentAvatarp->getPosition()+

+                                 LLVector3(head_offset)*gAgentAvatarp->getRotation()) * mat);

+        }

+        else

+        {

+            head_offset.mdV[VZ] += gAgentAvatarp->mHeadOffset.mV[VZ];

+            camera_position_global = gAgent.getPosGlobalFromAgent(gAgentAvatarp->getRenderPosition());//frame_center_global;

+            head_offset = head_offset * gAgentAvatarp->getRenderRotation();

+            camera_position_global = camera_position_global + head_offset;

+        }

+    }

+    else if (mCameraMode == CAMERA_MODE_THIRD_PERSON && mFocusOnAvatar)

+    {

+        LLVector3 local_camera_offset;

+        F32 camera_distance = 0.f;

+

+        if (mSitCameraEnabled

+            && isAgentAvatarValid()

+            && gAgentAvatarp->isSitting()

+            && mSitCameraReferenceObject.notNull())

+        {

+            // sit camera

+            LLVector3 object_pos = mSitCameraReferenceObject->getRenderPosition();

+            LLQuaternion object_rot = mSitCameraReferenceObject->getRenderRotation();

+

+            LLVector3 target_pos = object_pos + (mSitCameraPos * object_rot);

+

+            camera_position_global = gAgent.getPosGlobalFromAgent(target_pos);

+        }

+        else

+        {

+            static LLCachedControl<F32> camera_offset_scale(gSavedSettings, "CameraOffsetScale");

+            local_camera_offset = mCameraZoomFraction * getCameraOffsetInitial() * camera_offset_scale;

+

+            // are we sitting down?

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

+            {

+                LLQuaternion parent_rot = ((LLViewerObject*)gAgentAvatarp->getParent())->getRenderRotation();

+                // slam agent coordinate frame to proper parent local version

+                LLVector3 at_axis = gAgent.getFrameAgent().getAtAxis() * parent_rot;

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

+                at_axis.normalize();

+                gAgent.resetAxes(at_axis * ~parent_rot);

+

+                local_camera_offset = local_camera_offset * gAgent.getFrameAgent().getQuaternion() * parent_rot;

+            }

+            else

+            {

+                local_camera_offset = gAgent.getFrameAgent().rotateToAbsolute( local_camera_offset );

+            }

+

+            if (!isDisableCameraConstraints() && !mCameraCollidePlane.isExactlyZero() &&

+                (!isAgentAvatarValid() || !gAgentAvatarp->isSitting()))

+            {

+                LLVector3 plane_normal;

+                plane_normal.setVec(mCameraCollidePlane.mV);

+

+                F32 offset_dot_norm = local_camera_offset * plane_normal;

+                if (llabs(offset_dot_norm) < 0.001f)

+                {

+                    offset_dot_norm = 0.001f;

+                }

+

+                camera_distance = local_camera_offset.normalize();

+

+                F32 pos_dot_norm = gAgent.getPosAgentFromGlobal(frame_center_global + head_offset) * plane_normal;

+

+                // if agent is outside the colliding half-plane

+                if (pos_dot_norm > mCameraCollidePlane.mV[VW])

+                {

+                    // check to see if camera is on the opposite side (inside) the half-plane

+                    if (offset_dot_norm + pos_dot_norm < mCameraCollidePlane.mV[VW])

+                    {

+                        // diminish offset by factor to push it back outside the half-plane

+                        camera_distance *= (pos_dot_norm - mCameraCollidePlane.mV[VW] - CAMERA_COLLIDE_EPSILON) / -offset_dot_norm;

+                    }

+                }

+                else

+                {

+                    if (offset_dot_norm + pos_dot_norm > mCameraCollidePlane.mV[VW])

+                    {

+                        camera_distance *= (mCameraCollidePlane.mV[VW] - pos_dot_norm - CAMERA_COLLIDE_EPSILON) / offset_dot_norm;

+                    }

+                }

+            }

+            else

+            {

+                camera_distance = local_camera_offset.normalize();

+            }

+

+            mTargetCameraDistance = llmax(camera_distance, MIN_CAMERA_DISTANCE);

+

+            if (mTargetCameraDistance != mCurrentCameraDistance)

+            {

+                F32 camera_lerp_amt = LLSmoothInterpolation::getInterpolant(CAMERA_ZOOM_HALF_LIFE);

+

+                mCurrentCameraDistance = lerp(mCurrentCameraDistance, mTargetCameraDistance, camera_lerp_amt);

+            }

+

+            // Make the camera distance current

+            local_camera_offset *= mCurrentCameraDistance;

+

+            // set the global camera position

+            LLVector3d camera_offset;

+

+            camera_offset.setVec( local_camera_offset );

+            camera_position_global = frame_center_global + head_offset + camera_offset;

+

+            if (isAgentAvatarValid())

+            {

+                LLVector3d camera_lag_d;

+                F32 lag_interp = LLSmoothInterpolation::getInterpolant(CAMERA_LAG_HALF_LIFE);

+                LLVector3 target_lag;

+                LLVector3 vel = gAgent.getVelocity();

+

+                // lag by appropriate amount for flying

+                F32 time_in_air = gAgentAvatarp->mTimeInAir.getElapsedTimeF32();

+                if(!mCameraAnimating && gAgentAvatarp->mInAir && time_in_air > GROUND_TO_AIR_CAMERA_TRANSITION_START_TIME)

+                {

+                    LLVector3 frame_at_axis = gAgent.getFrameAgent().getAtAxis();

+                    frame_at_axis -= projected_vec(frame_at_axis, gAgent.getReferenceUpVector());

+                    frame_at_axis.normalize();

+

+                    //transition smoothly in air mode, to avoid camera pop

+                    F32 u = (time_in_air - GROUND_TO_AIR_CAMERA_TRANSITION_START_TIME) / GROUND_TO_AIR_CAMERA_TRANSITION_TIME;

+                    u = llclamp(u, 0.f, 1.f);

+

+                    lag_interp *= u;

+

+                    if (gViewerWindow->getLeftMouseDown() && gViewerWindow->getLastPick().mObjectID == gAgentAvatarp->getID())

+                    {

+                        // disable camera lag when using mouse-directed steering

+                        target_lag.clearVec();

+                    }

+                    else

+                    {

+                        LLCachedControl<F32> dynamic_camera_strength(gSavedSettings, "DynamicCameraStrength");

+                        target_lag = vel * dynamic_camera_strength / 30.f;

+                    }

+

+                    mCameraLag = lerp(mCameraLag, target_lag, lag_interp);

+

+                    F32 lag_dist = mCameraLag.magVec();

+                    if (lag_dist > MAX_CAMERA_LAG)

+                    {

+                        mCameraLag = mCameraLag * MAX_CAMERA_LAG / lag_dist;

+                    }

+

+                    // clamp camera lag so that avatar is always in front

+                    F32 dot = (mCameraLag - (frame_at_axis * (MIN_CAMERA_LAG * u))) * frame_at_axis;

+                    if (dot < -(MIN_CAMERA_LAG * u))

+                    {

+                        mCameraLag -= (dot + (MIN_CAMERA_LAG * u)) * frame_at_axis;

+                    }

+                }

+                else

+                {

+                    mCameraLag = lerp(mCameraLag, LLVector3::zero, LLSmoothInterpolation::getInterpolant(0.15f));

+                }

+

+                camera_lag_d.setVec(mCameraLag);

+                camera_position_global = camera_position_global - camera_lag_d;

+            }

+        }

+    }

+    else

+    {

+        LLVector3d focusPosGlobal = calcFocusPositionTargetGlobal();

+        // camera gets pushed out later wrt mCameraFOVZoomFactor...this is "raw" value

+        camera_position_global = focusPosGlobal + mCameraFocusOffset;

+    }

+

+    if (!isDisableCameraConstraints() && !gAgent.isGodlike())

+    {

+        LLViewerRegion* regionp = LLWorld::getInstance()->getRegionFromPosGlobal(camera_position_global);

+        bool constrain = true;

+        if(regionp && regionp->canManageEstate())

+        {

+            constrain = false;

+        }

+        if(constrain)

+        {

+            F32 max_dist = (CAMERA_MODE_CUSTOMIZE_AVATAR == mCameraMode) ? APPEARANCE_MAX_ZOOM : mDrawDistance;

+

+            LLVector3d camera_offset = camera_position_global - gAgent.getPositionGlobal();

+            F32 camera_distance = (F32)camera_offset.magVec();

+

+            if(camera_distance > max_dist)

+            {

+                camera_position_global = gAgent.getPositionGlobal() + (max_dist/camera_distance)*camera_offset;

+                isConstrained = true;

+            }

+        }

+

+// JC - Could constrain camera based on parcel stuff here.

+//          LLViewerRegion *regionp = LLWorld::getInstance()->getRegionFromPosGlobal(camera_position_global);

+//

+//          if (regionp && !regionp->mParcelOverlay->isBuildCameraAllowed(regionp->getPosRegionFromGlobal(camera_position_global)))

+//          {

+//              camera_position_global = last_position_global;

+//

+//              isConstrained = true;

+//          }

+    }

+

+    // Don't let camera go underground

+    F32 camera_min_off_ground = getCameraMinOffGround();

+    camera_land_height = LLWorld::getInstance()->resolveLandHeightGlobal(camera_position_global);

+    F32 minZ = llmax(F_ALMOST_ZERO, camera_land_height + camera_min_off_ground);

+    if (camera_position_global.mdV[VZ] < minZ)

+    {

+        camera_position_global.mdV[VZ] = minZ;

+        isConstrained = true;

+    }

+

+    if (hit_limit)

+    {

+        *hit_limit = isConstrained;

+    }

+

+    return camera_position_global;

+}

+

+

+LLVector3 LLAgentCamera::getCurrentCameraOffset()

+{

+    return (LLViewerCamera::getInstance()->getOrigin() - getAvatarRootPosition() - mThirdPersonHeadOffset) * ~getCurrentAvatarRotation();

+}

+

+LLVector3d LLAgentCamera::getCurrentFocusOffset()

+{

+    return (mFocusTargetGlobal - gAgent.getPositionGlobal()) * ~getCurrentAvatarRotation();

+}

+

+LLQuaternion LLAgentCamera::getCurrentAvatarRotation()

+{

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

+

+    LLQuaternion av_rot = gAgent.getFrameAgent().getQuaternion();

+    LLQuaternion obj_rot = sit_object ? sit_object->getRenderRotation() : LLQuaternion::DEFAULT;

+    return av_rot * obj_rot;

+}

+

+bool LLAgentCamera::isJoystickCameraUsed()

+{

+    return ((mOrbitAroundRadians != 0) || (mOrbitOverAngle != 0) || !mPanFocusDiff.isNull());

+}

+

+LLVector3 LLAgentCamera::getCameraOffsetInitial()

+{

+    // getCameraOffsetInitial and getFocusOffsetInitial can be called on update from idle before init()

+    static LLCachedControl<LLVector3> camera_offset_initial (gSavedSettings, "CameraOffsetRearView", LLVector3());

+    return camera_offset_initial;

+}

+

+LLVector3d LLAgentCamera::getFocusOffsetInitial()

+{

+    static LLCachedControl<LLVector3d> focus_offset_initial(gSavedSettings, "FocusOffsetRearView", LLVector3d());

+    return focus_offset_initial;

+}

+

+F32 LLAgentCamera::getCameraMaxZoomDistance()

+{

+    // SL-14706 / SL-14885 TPV have relaxed camera constraints allowing you to mousewheeel zoom WAY out.

+    static LLCachedControl<bool> s_disable_camera_constraints(gSavedSettings, "DisableCameraConstraints", false);

+    if (s_disable_camera_constraints)

+    {

+        return (F32)INT_MAX;

+    }

+

+    // Ignore "DisableCameraConstraints", we don't want to be out of draw range when we focus onto objects or avatars

+    return llmin(MAX_CAMERA_DISTANCE_FROM_OBJECT,

+                 mDrawDistance - 1, // convenience, don't hit draw limit when focusing on something

+                 LLWorld::getInstance()->getRegionWidthInMeters() - CAMERA_FUDGE_FROM_OBJECT);

+}

+

+LLVector3 LLAgentCamera::getAvatarRootPosition()

+{

+    static LLCachedControl<bool> use_hover_height(gSavedSettings, "HoverHeightAffectsCamera");

+    return use_hover_height ? gAgentAvatarp->mRoot->getWorldPosition() : gAgentAvatarp->mRoot->getWorldPosition() - gAgentAvatarp->getHoverOffset();

+

+}

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

+// handleScrollWheel()

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

+void LLAgentCamera::handleScrollWheel(S32 clicks)

+{

+    if (mCameraMode == CAMERA_MODE_FOLLOW && getFocusOnAvatar())

+    {

+        if (!mFollowCam.getPositionLocked()) // not if the followCam position is locked in place

+        {

+            mFollowCam.zoom(clicks);

+            if (mFollowCam.isZoomedToMinimumDistance())

+            {

+                changeCameraToMouselook(false);

+            }

+        }

+    }

+    else

+    {

+        LLObjectSelectionHandle selection = LLSelectMgr::getInstance()->getSelection();

+        const F32 ROOT_ROOT_TWO = sqrt(F_SQRT2);

+

+        // Block if camera is animating

+        if (mCameraAnimating)

+        {

+            return;

+        }

+

+        if (selection->getObjectCount() && selection->getSelectType() == SELECT_TYPE_HUD)

+        {

+            F32 zoom_factor = (F32)pow(0.8, -clicks);

+            cameraZoomIn(zoom_factor);

+        }

+        else if (mFocusOnAvatar && (mCameraMode == CAMERA_MODE_THIRD_PERSON))

+        {

+            F32 camera_offset_initial_mag = getCameraOffsetInitial().magVec();

+

+            F32 current_zoom_fraction = mTargetCameraDistance / (camera_offset_initial_mag * gSavedSettings.getF32("CameraOffsetScale"));

+            current_zoom_fraction *= 1.f - pow(ROOT_ROOT_TWO, clicks);

+

+            cameraOrbitIn(current_zoom_fraction * camera_offset_initial_mag * gSavedSettings.getF32("CameraOffsetScale"));

+        }

+        else

+        {

+            F32 current_zoom_fraction = (F32)mCameraFocusOffsetTarget.magVec();

+            cameraOrbitIn(current_zoom_fraction * (1.f - pow(ROOT_ROOT_TWO, clicks)));

+        }

+    }

+}

+

+

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

+// getCameraMinOffGround()

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

+F32 LLAgentCamera::getCameraMinOffGround()

+{

+    if (mCameraMode == CAMERA_MODE_MOUSELOOK)

+    {

+        return 0.f;

+    }

+

+    if (isDisableCameraConstraints())

+    {

+        return -1000.f;

+    }

+

+    return 0.5f;

+}

+

+

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

+// resetCamera()

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

+void LLAgentCamera::resetCamera()

+{

+    // Remove any pitch from the avatar

+    LLVector3 at = gAgent.getFrameAgent().getAtAxis();

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

+    at.normalize();

+    gAgent.resetAxes(at);

+    // have to explicitly clear field of view zoom now

+    mCameraFOVZoomFactor = 0.f;

+

+    updateCamera();

+}

+

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

+// changeCameraToMouselook()

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

+void LLAgentCamera::changeCameraToMouselook(bool animate)

+{

+    if (!gSavedSettings.getBOOL("EnableMouselook")

+        || LLViewerJoystick::getInstance()->getOverrideCamera())

+    {

+        return;

+    }

+

+    // visibility changes at end of animation

+    gViewerWindow->getWindow()->resetBusyCount();

+

+    // Menus should not remain open on switching to mouselook...

+    LLMenuGL::sMenuContainer->hideMenus();

+    LLUI::getInstance()->clearPopups();

+

+    // unpause avatar animation

+    gAgent.unpauseAnimation();

+

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

+

+    if (isAgentAvatarValid())

+    {

+        gAgentAvatarp->stopMotion(ANIM_AGENT_BODY_NOISE);

+        gAgentAvatarp->stopMotion(ANIM_AGENT_BREATHE_ROT);

+    }

+

+    //gViewerWindow->stopGrab();

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

+    gViewerWindow->hideCursor();

+    gViewerWindow->moveCursorToCenter();

+

+    if (mCameraMode != CAMERA_MODE_MOUSELOOK)

+    {

+        gFocusMgr.setKeyboardFocus(NULL);

+

+        updateLastCamera();

+        mCameraMode = CAMERA_MODE_MOUSELOOK;

+        const U32 old_flags = gAgent.getControlFlags();

+        gAgent.setControlFlags(AGENT_CONTROL_MOUSELOOK);

+        if (old_flags != gAgent.getControlFlags())

+        {

+            gAgent.setFlagsDirty();

+        }

+

+        if (animate)

+        {

+            startCameraAnimation();

+        }

+        else

+        {

+            mCameraAnimating = false;

+            gAgent.endAnimationUpdateUI();

+        }

+    }

+}

+

+

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

+// changeCameraToDefault()

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

+void LLAgentCamera::changeCameraToDefault()

+{

+    if (LLViewerJoystick::getInstance()->getOverrideCamera())

+    {

+        return;

+    }

+

+    if (LLFollowCamMgr::getInstance()->getActiveFollowCamParams())

+    {

+        changeCameraToFollow();

+    }

+    else

+    {

+        changeCameraToThirdPerson();

+    }

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

+    {

+        gViewerWindow->setUIVisibility(false);

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

+    }

+}

+

+

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

+// changeCameraToFollow()

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

+void LLAgentCamera::changeCameraToFollow(bool animate)

+{

+    if (LLViewerJoystick::getInstance()->getOverrideCamera())

+    {

+        return;

+    }

+

+    if(mCameraMode != CAMERA_MODE_FOLLOW)

+    {

+        if (mCameraMode == CAMERA_MODE_MOUSELOOK)

+        {

+            animate = false;

+        }

+        startCameraAnimation();

+

+        updateLastCamera();

+        mCameraMode = CAMERA_MODE_FOLLOW;

+

+        // bang-in the current focus, position, and up vector of the follow cam

+        mFollowCam.reset(mCameraPositionAgent, LLViewerCamera::getInstance()->getPointOfInterest(), LLVector3::z_axis);

+

+        if (gBasicToolset)

+        {

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

+        }

+

+        if (isAgentAvatarValid())

+        {

+            // SL-315

+            gAgentAvatarp->mPelvisp->setPosition(LLVector3::zero);

+            gAgentAvatarp->startMotion( ANIM_AGENT_BODY_NOISE );

+            gAgentAvatarp->startMotion( ANIM_AGENT_BREATHE_ROT );

+        }

+

+        // unpause avatar animation

+        gAgent.unpauseAnimation();

+

+        gAgent.clearControlFlags(AGENT_CONTROL_MOUSELOOK);

+

+        if (animate)

+        {

+            startCameraAnimation();

+        }

+        else

+        {

+            mCameraAnimating = false;

+            gAgent.endAnimationUpdateUI();

+        }

+    }

+}

+

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

+// changeCameraToThirdPerson()

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

+void LLAgentCamera::changeCameraToThirdPerson(bool animate)

+{

+    if (LLViewerJoystick::getInstance()->getOverrideCamera())

+    {

+        return;

+    }

+

+    gViewerWindow->getWindow()->resetBusyCount();

+

+    mCameraZoomFraction = INITIAL_ZOOM_FRACTION;

+

+    if (isAgentAvatarValid())

+    {

+        if (!gAgentAvatarp->isSitting())

+        {

+            // SL-315

+            gAgentAvatarp->mPelvisp->setPosition(LLVector3::zero);

+        }

+        gAgentAvatarp->startMotion(ANIM_AGENT_BODY_NOISE);

+        gAgentAvatarp->startMotion(ANIM_AGENT_BREATHE_ROT);

+    }

+

+    LLVector3 at_axis;

+

+    // unpause avatar animation

+    gAgent.unpauseAnimation();

+

+    if (mCameraMode != CAMERA_MODE_THIRD_PERSON)

+    {

+        if (gBasicToolset)

+        {

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

+        }

+

+        mCameraLag.clearVec();

+        if (mCameraMode == CAMERA_MODE_MOUSELOOK)

+        {

+            mCurrentCameraDistance = MIN_CAMERA_DISTANCE;

+            mTargetCameraDistance = MIN_CAMERA_DISTANCE;

+            animate = false;

+        }

+        updateLastCamera();

+        mCameraMode = CAMERA_MODE_THIRD_PERSON;

+        gAgent.clearControlFlags(AGENT_CONTROL_MOUSELOOK);

+    }

+

+    // Remove any pitch from the avatar

+    if (!isAgentAvatarValid() || !gAgentAvatarp->getParent())

+    {

+        at_axis = gAgent.getFrameAgent().getAtAxis();

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

+        at_axis.normalize();

+        gAgent.resetAxes(at_axis);

+    }

+

+

+    if (animate)

+    {

+        startCameraAnimation();

+    }

+    else

+    {

+        mCameraAnimating = false;

+        gAgent.endAnimationUpdateUI();

+    }

+}

+

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

+// changeCameraToCustomizeAvatar()

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

+void LLAgentCamera::changeCameraToCustomizeAvatar()

+{

+    if (LLViewerJoystick::getInstance()->getOverrideCamera() || !isAgentAvatarValid())

+    {

+        return;

+    }

+

+    gAgent.standUp(); // force stand up

+    gViewerWindow->getWindow()->resetBusyCount();

+

+    if (LLSelectMgr::getInstance()->getSelection()->isAttachment())

+    {

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

+    }

+

+    if (gFaceEditToolset)

+    {

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

+    }

+

+    startCameraAnimation();

+

+    if (mCameraMode != CAMERA_MODE_CUSTOMIZE_AVATAR)

+    {

+        updateLastCamera();

+        mCameraMode = CAMERA_MODE_CUSTOMIZE_AVATAR;

+        gAgent.clearControlFlags(AGENT_CONTROL_MOUSELOOK);

+

+        gFocusMgr.setKeyboardFocus( NULL );

+        gFocusMgr.setMouseCapture( NULL );

+        if( gMorphView )

+        {

+            gMorphView->setVisible( true );

+        }

+        // Remove any pitch or rotation from the avatar

+        LLVector3 at = gAgent.getAtAxis();

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

+        at.normalize();

+        gAgent.resetAxes(at);

+

+        gAgent.sendAnimationRequest(ANIM_AGENT_CUSTOMIZE, ANIM_REQUEST_START);

+        gAgent.setCustomAnim(true);

+        gAgentAvatarp->startMotion(ANIM_AGENT_CUSTOMIZE);

+        LLMotion* turn_motion = gAgentAvatarp->findMotion(ANIM_AGENT_CUSTOMIZE);

+

+        if (turn_motion)

+        {

+            // delay camera animation long enough to play through turn animation

+            setAnimationDuration(turn_motion->getDuration() + CUSTOMIZE_AVATAR_CAMERA_ANIM_SLOP);

+        }

+    }

+

+    LLVector3 agent_at = gAgent.getAtAxis();

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

+    agent_at.normalize();

+

+    // default focus point for customize avatar

+    LLVector3 focus_target = isAgentAvatarValid()

+        ? gAgentAvatarp->mHeadp->getWorldPosition()

+        : gAgent.getPositionAgent();

+

+    LLVector3d camera_offset(agent_at * -1.0);

+    // push camera up and out from avatar

+    camera_offset.mdV[VZ] = 0.1f;

+    camera_offset *= CUSTOMIZE_AVATAR_CAMERA_DEFAULT_DIST;

+    LLVector3d focus_target_global = gAgent.getPosGlobalFromAgent(focus_target);

+    setAnimationDuration(gSavedSettings.getF32("ZoomTime"));

+    setCameraPosAndFocusGlobal(focus_target_global + camera_offset, focus_target_global, gAgent.getID());

+}

+

+

+void LLAgentCamera::switchCameraPreset(ECameraPreset preset)

+{

+    //zoom is supposed to be reset for the front and group views

+    mCameraZoomFraction = 1.f;

+

+    //focusing on avatar in that case means following him on movements

+    mFocusOnAvatar = true;

+

+    mCameraPreset = preset;

+

+    resetPanDiff();

+    resetOrbitDiff();

+

+    gSavedSettings.setU32("CameraPresetType", mCameraPreset);

+}

+

+

+//

+// Focus point management

+//

+

+void LLAgentCamera::setAnimationDuration(F32 duration)

+{

+    if (mCameraAnimating)

+    {

+        // do not cut any existing camera animation short

+        F32 animation_left = llmax(0.f, mAnimationDuration - mAnimationTimer.getElapsedTimeF32());

+        mAnimationDuration = llmax(duration, animation_left);

+    }

+    else

+    {

+        mAnimationDuration = duration;

+    }

+}

+

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

+// startCameraAnimation()

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

+void LLAgentCamera::startCameraAnimation()

+{

+    mAnimationCameraStartGlobal = getCameraPositionGlobal();

+    mAnimationFocusStartGlobal = mFocusGlobal;

+    setAnimationDuration(gSavedSettings.getF32("ZoomTime"));

+    mAnimationTimer.reset();

+    mCameraAnimating = true;

+}

+

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

+// stopCameraAnimation()

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

+void LLAgentCamera::stopCameraAnimation()

+{

+    mCameraAnimating = false;

+}

+

+void LLAgentCamera::clearFocusObject()

+{

+    if (mFocusObject.notNull())

+    {

+        startCameraAnimation();

+

+        setFocusObject(NULL);

+        mFocusObjectOffset.clearVec();

+    }

+}

+

+void LLAgentCamera::setFocusObject(LLViewerObject* object)

+{

+    mFocusObject = object;

+}

+

+// Focus on a point, but try to keep camera position stable.

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

+// setFocusGlobal()

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

+void LLAgentCamera::setFocusGlobal(const LLPickInfo& pick)

+{

+    LLViewerObject* objectp = gObjectList.findObject(pick.mObjectID);

+

+    if (objectp)

+    {

+        // focus on object plus designated offset

+        // which may or may not be same as pick.mPosGlobal

+        setFocusGlobal(objectp->getPositionGlobal() + LLVector3d(pick.mObjectOffset), pick.mObjectID);

+    }

+    else

+    {

+        // focus directly on point where user clicked

+        setFocusGlobal(pick.mPosGlobal, pick.mObjectID);

+    }

+}

+

+

+void LLAgentCamera::setFocusGlobal(const LLVector3d& focus, const LLUUID &object_id)

+{

+    setFocusObject(gObjectList.findObject(object_id));

+    LLVector3d old_focus = mFocusTargetGlobal;

+    LLViewerObject *focus_obj = mFocusObject;

+

+    // if focus has changed

+    if (old_focus != focus)

+    {

+        if (focus.isExactlyZero())

+        {

+            if (isAgentAvatarValid())

+            {

+                mFocusTargetGlobal = gAgent.getPosGlobalFromAgent(gAgentAvatarp->mHeadp->getWorldPosition());

+            }

+            else

+            {

+                mFocusTargetGlobal = gAgent.getPositionGlobal();

+            }

+            mCameraFocusOffsetTarget = getCameraPositionGlobal() - mFocusTargetGlobal;

+            mCameraFocusOffset = mCameraFocusOffsetTarget;

+            setLookAt(LOOKAT_TARGET_CLEAR);

+        }

+        else

+        {

+            mFocusTargetGlobal = focus;

+            if (!focus_obj)

+            {

+                mCameraFOVZoomFactor = 0.f;

+            }

+

+            mCameraFocusOffsetTarget = gAgent.getPosGlobalFromAgent(mCameraVirtualPositionAgent) - mFocusTargetGlobal;

+

+            startCameraAnimation();

+

+            if (focus_obj)

+            {

+                if (focus_obj->isAvatar())

+                {

+                    setLookAt(LOOKAT_TARGET_FOCUS, focus_obj);

+                }

+                else

+                {

+                    setLookAt(LOOKAT_TARGET_FOCUS, focus_obj, (gAgent.getPosAgentFromGlobal(focus) - focus_obj->getRenderPosition()) * ~focus_obj->getRenderRotation());

+                }

+            }

+            else

+            {

+                setLookAt(LOOKAT_TARGET_FOCUS, NULL, gAgent.getPosAgentFromGlobal(mFocusTargetGlobal));

+            }

+        }

+    }

+    else // focus == mFocusTargetGlobal

+    {

+        if (focus.isExactlyZero())

+        {

+            if (isAgentAvatarValid())

+            {

+                mFocusTargetGlobal = gAgent.getPosGlobalFromAgent(gAgentAvatarp->mHeadp->getWorldPosition());

+            }

+            else

+            {

+                mFocusTargetGlobal = gAgent.getPositionGlobal();

+            }

+        }

+        mCameraFocusOffsetTarget = (getCameraPositionGlobal() - mFocusTargetGlobal) / (1.f + mCameraFOVZoomFactor);;

+        mCameraFocusOffset = mCameraFocusOffsetTarget;

+    }

+

+    if (mFocusObject.notNull())

+    {

+        // for attachments, make offset relative to avatar, not the attachment

+        if (mFocusObject->isAttachment())

+        {

+            while (mFocusObject.notNull() && !mFocusObject->isAvatar())

+            {

+                mFocusObject = (LLViewerObject*) mFocusObject->getParent();

+            }

+            setFocusObject((LLViewerObject*)mFocusObject);

+        }

+        updateFocusOffset();

+    }

+}

+

+// Used for avatar customization

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

+// setCameraPosAndFocusGlobal()

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

+void LLAgentCamera::setCameraPosAndFocusGlobal(const LLVector3d& camera_pos, const LLVector3d& focus, const LLUUID &object_id)

+{

+    LLVector3d old_focus = mFocusTargetGlobal.isExactlyZero() ? focus : mFocusTargetGlobal;

+

+    F64 focus_delta_squared = (old_focus - focus).magVecSquared();

+    const F64 ANIM_EPSILON_SQUARED = 0.0001;

+    if (focus_delta_squared > ANIM_EPSILON_SQUARED)

+    {

+        startCameraAnimation();

+    }

+

+    //LLViewerCamera::getInstance()->setOrigin( gAgent.getPosAgentFromGlobal( camera_pos ) );

+    setFocusObject(gObjectList.findObject(object_id));

+    mFocusTargetGlobal = focus;

+    mCameraFocusOffsetTarget = camera_pos - focus;

+    mCameraFocusOffset = mCameraFocusOffsetTarget;

+

+    if (mFocusObject)

+    {

+        if (mFocusObject->isAvatar())

+        {

+            setLookAt(LOOKAT_TARGET_FOCUS, mFocusObject);

+        }

+        else

+        {

+            setLookAt(LOOKAT_TARGET_FOCUS, mFocusObject, (gAgent.getPosAgentFromGlobal(focus) - mFocusObject->getRenderPosition()) * ~mFocusObject->getRenderRotation());

+        }

+    }

+    else

+    {

+        setLookAt(LOOKAT_TARGET_FOCUS, NULL, gAgent.getPosAgentFromGlobal(mFocusTargetGlobal));

+    }

+

+    if (mCameraAnimating)

+    {

+        const F64 ANIM_METERS_PER_SECOND = 10.0;

+        const F64 MIN_ANIM_SECONDS = 0.5;

+        const F64 MAX_ANIM_SECONDS = 10.0;

+        F64 anim_duration = llmax( MIN_ANIM_SECONDS, sqrt(focus_delta_squared) / ANIM_METERS_PER_SECOND );

+        anim_duration = llmin( anim_duration, MAX_ANIM_SECONDS );

+        setAnimationDuration( (F32)anim_duration );

+    }

+

+    updateFocusOffset();

+}

+

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

+// setSitCamera()

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

+void LLAgentCamera::setSitCamera(const LLUUID &object_id, const LLVector3 &camera_pos, const LLVector3 &camera_focus)

+{

+    bool camera_enabled = !object_id.isNull();

+

+    if (camera_enabled)

+    {

+        LLViewerObject *reference_object = gObjectList.findObject(object_id);

+        if (reference_object)

+        {

+            //convert to root object relative?

+            mSitCameraPos = camera_pos;

+            mSitCameraFocus = camera_focus;

+            mSitCameraReferenceObject = reference_object;

+            mSitCameraEnabled = true;

+        }

+    }

+    else

+    {

+        mSitCameraPos.clearVec();

+        mSitCameraFocus.clearVec();

+        mSitCameraReferenceObject = NULL;

+        mSitCameraEnabled = false;

+    }

+}

+

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

+// setFocusOnAvatar()

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

+void LLAgentCamera::setFocusOnAvatar(bool focus_on_avatar, bool animate, bool reset_axes)

+{

+    if (focus_on_avatar != mFocusOnAvatar)

+    {

+        if (animate)

+        {

+            startCameraAnimation();

+        }

+        else

+        {

+            stopCameraAnimation();

+        }

+    }

+

+    //RN: when focused on the avatar, we're not "looking" at it

+    // looking implies intent while focusing on avatar means

+    // you're just walking around with a camera on you...eesh.

+    if (!mFocusOnAvatar && focus_on_avatar && reset_axes)

+    {

+        setFocusGlobal(LLVector3d::zero);

+        mCameraFOVZoomFactor = 0.f;

+        if (mCameraMode == CAMERA_MODE_THIRD_PERSON)

+        {

+            LLVector3 at_axis;

+            if (!isAgentAvatarValid() || !gAgentAvatarp->getParent())

+            {

+                // In case of front view rotate agent to look into direction opposite to camera

+                // In case of rear view rotate agent into diraction same as camera, e t c

+                LLVector3 vect = getCameraOffsetInitial();

+                F32 rotxy = F32(atan2(vect.mV[VY], vect.mV[VX]));

+

+                LLCoordFrame frameCamera = *((LLCoordFrame*)LLViewerCamera::getInstance());

+                // front view angle rotxy is zero, rear view rotxy angle is 180, compensate

+                frameCamera.yaw((180 * DEG_TO_RAD) - rotxy);

+                at_axis = frameCamera.getAtAxis();

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

+                at_axis.normalize();

+                gAgent.resetAxes(at_axis);

+                gAgent.yaw(0);

+            }

+        }

+    }

+    // unlocking camera from avatar

+    else if (mFocusOnAvatar && !focus_on_avatar)

+    {

+        // keep camera focus point consistent, even though it is now unlocked

+        setFocusGlobal(gAgent.getPositionGlobal() + calcThirdPersonFocusOffset(), gAgent.getID());

+        mAllowChangeToFollow = false;

+    }

+

+    mFocusOnAvatar = focus_on_avatar;

+}

+

+

+bool LLAgentCamera::setLookAt(ELookAtType target_type, LLViewerObject *object, LLVector3 position)

+{

+    if(object && object->isAttachment())

+    {

+        LLViewerObject* parent = object;

+        while(parent)

+        {

+            if (parent == gAgentAvatarp)

+            {

+                // looking at an attachment on ourselves, which we don't want to do

+                object = gAgentAvatarp;

+                position.clearVec();

+            }

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

+        }

+    }

+    if(!mLookAt || mLookAt->isDead())

+    {

+        mLookAt = (LLHUDEffectLookAt *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_LOOKAT);

+        mLookAt->setSourceObject(gAgentAvatarp);

+    }

+

+    return mLookAt->setLookAt(target_type, object, position);

+}

+

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

+// lookAtLastChat()

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

+void LLAgentCamera::lookAtLastChat()

+{

+    // Block if camera is animating or not in normal third person camera mode

+    if (mCameraAnimating || !cameraThirdPerson())

+    {

+        return;

+    }

+

+    LLViewerObject *chatter = gObjectList.findObject(gAgent.getLastChatter());

+    if (!chatter)

+    {

+        return;

+    }

+

+    LLVector3 delta_pos;

+    if (chatter->isAvatar())

+    {

+        LLVOAvatar *chatter_av = (LLVOAvatar*)chatter;

+        if (isAgentAvatarValid() && chatter_av->mHeadp)

+        {

+            delta_pos = chatter_av->mHeadp->getWorldPosition() - gAgentAvatarp->mHeadp->getWorldPosition();

+        }

+        else

+        {

+            delta_pos = chatter->getPositionAgent() - gAgent.getPositionAgent();

+        }

+        delta_pos.normalize();

+

+        gAgent.setControlFlags(AGENT_CONTROL_STOP);

+

+        changeCameraToThirdPerson();

+

+        LLVector3 new_camera_pos = gAgentAvatarp->mHeadp->getWorldPosition();

+        LLVector3 left = delta_pos % LLVector3::z_axis;

+        left.normalize();

+        LLVector3 up = left % delta_pos;

+        up.normalize();

+        new_camera_pos -= delta_pos * 0.4f;

+        new_camera_pos += left * 0.3f;

+        new_camera_pos += up * 0.2f;

+

+        setFocusOnAvatar(false, false);

+

+        if (chatter_av->mHeadp)

+        {

+            setFocusGlobal(gAgent.getPosGlobalFromAgent(chatter_av->mHeadp->getWorldPosition()), gAgent.getLastChatter());

+            mCameraFocusOffsetTarget = gAgent.getPosGlobalFromAgent(new_camera_pos) - gAgent.getPosGlobalFromAgent(chatter_av->mHeadp->getWorldPosition());

+        }

+        else

+        {

+            setFocusGlobal(chatter->getPositionGlobal(), gAgent.getLastChatter());

+            mCameraFocusOffsetTarget = gAgent.getPosGlobalFromAgent(new_camera_pos) - chatter->getPositionGlobal();

+        }

+    }

+    else

+    {

+        delta_pos = chatter->getRenderPosition() - gAgent.getPositionAgent();

+        delta_pos.normalize();

+

+        gAgent.setControlFlags(AGENT_CONTROL_STOP);

+

+        changeCameraToThirdPerson();

+

+        LLVector3 new_camera_pos = gAgentAvatarp->mHeadp->getWorldPosition();

+        LLVector3 left = delta_pos % LLVector3::z_axis;

+        left.normalize();

+        LLVector3 up = left % delta_pos;

+        up.normalize();

+        new_camera_pos -= delta_pos * 0.4f;

+        new_camera_pos += left * 0.3f;

+        new_camera_pos += up * 0.2f;

+

+        setFocusOnAvatar(false, false);

+

+        setFocusGlobal(chatter->getPositionGlobal(), gAgent.getLastChatter());

+        mCameraFocusOffsetTarget = gAgent.getPosGlobalFromAgent(new_camera_pos) - chatter->getPositionGlobal();

+    }

+}

+

+bool LLAgentCamera::isfollowCamLocked()

+{

+    return mFollowCam.getPositionLocked();

+}

+

+bool LLAgentCamera::setPointAt(EPointAtType target_type, LLViewerObject *object, LLVector3 position)

+{

+    // disallow pointing at attachments and avatars

+    if (object && (object->isAttachment() || object->isAvatar()))

+    {

+        return false;

+    }

+    if (!mPointAt || mPointAt->isDead())

+    {

+        mPointAt = (LLHUDEffectPointAt *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_POINTAT);

+        mPointAt->setSourceObject(gAgentAvatarp);

+    }

+    return mPointAt->setPointAt(target_type, object, position);

+}

+

+void LLAgentCamera::rotateToInitSitRot()

+{

+    gAgent.rotate(~gAgent.getFrameAgent().getQuaternion());

+    gAgent.rotate(mInitSitRot);

+}

+

+void LLAgentCamera::resetCameraZoomFraction()

+{

+    mCameraZoomFraction = INITIAL_ZOOM_FRACTION;

+}

+

+ELookAtType LLAgentCamera::getLookAtType()

+{

+    if (mLookAt)

+    {

+        return mLookAt->getLookAtType();

+    }

+    return LOOKAT_TARGET_NONE;

+}

+

+EPointAtType LLAgentCamera::getPointAtType()

+{

+    if (mPointAt)

+    {

+        return mPointAt->getPointAtType();

+    }

+    return POINTAT_TARGET_NONE;

+}

+

+void LLAgentCamera::clearGeneralKeys()

+{

+    mAtKey              = 0;

+    mWalkKey            = 0;

+    mLeftKey            = 0;

+    mUpKey              = 0;

+    mYawKey             = 0.f;

+    mPitchKey           = 0.f;

+}

+

+void LLAgentCamera::clearOrbitKeys()

+{

+    mOrbitLeftKey       = 0.f;

+    mOrbitRightKey      = 0.f;

+    mOrbitUpKey         = 0.f;

+    mOrbitDownKey       = 0.f;

+    mOrbitInKey         = 0.f;

+    mOrbitOutKey        = 0.f;

+}

+

+void LLAgentCamera::clearPanKeys()

+{

+    mPanRightKey        = 0.f;

+    mPanLeftKey         = 0.f;

+    mPanUpKey           = 0.f;

+    mPanDownKey         = 0.f;

+    mPanInKey           = 0.f;

+    mPanOutKey          = 0.f;

+}

+

+// static

+S32 LLAgentCamera::directionToKey(S32 direction)

+{

+    if (direction > 0) return 1;

+    if (direction < 0) return -1;

+    return 0;

+}

+

+

+// EOF

+