EXT-2959 : Pull out camera functions from llagent to llagentcamera

#2 checkin.

Superficial cleanup and some bug fixing (e.g. took out duplicate mDrawDistance from llagent, took out gAgentCameraHACK and gAgentHACK).

13 files changed, 297 insertions, 3192 deletions

diff --git a/indra/newview/llagent.cpp b/indra/newview/llagent.cpp
index 5ee026f021..5dd4215206 100644
--- a/indra/newview/llagent.cpp
+++ b/indra/newview/llagent.cpp
@@ -82,8 +82,6 @@
 #include "llworld.h"
 #include "llworldmap.h"
 
-LLAgentCamera gAgentCameraHACK; // Seraph delete
-
 using namespace LLVOAvatarDefines;
 
 extern LLMenuBarGL* gMenuBarView;
@@ -110,65 +108,20 @@ const F32 AUTOPILOT_MAX_TIME_NO_PROGRESS = 1.5f;		// seconds
 const LLVector3d FACE_EDIT_CAMERA_OFFSET(0.4f, -0.05f, 0.07f);
 const LLVector3d FACE_EDIT_TARGET_OFFSET(0.f, 0.f, 0.05f);
 
-/*
-// 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 METERS_PER_WHEEL_CLICK = 1.f;
 
 const F32 MAX_TIME_DELTA = 1.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_SMOOTH_DISTANCE = 50.0f;
-
-const F32 HEAD_BUFFER_SIZE = 0.3f;
-const F32 CUSTOMIZE_AVATAR_CAMERA_ANIM_SLOP = 0.2f;
-
-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;
-*/
-
 // fidget constants
 const F32 MIN_FIDGET_TIME = 8.f; // seconds
 const F32 MAX_FIDGET_TIME = 20.f; // seconds
 
 const S32 MAX_NUM_CHAT_POSITIONS = 10;
-/*
-const F32 GROUND_TO_AIR_CAMERA_TRANSITION_TIME = 0.5f;
-const F32 GROUND_TO_AIR_CAMERA_TRANSITION_START_TIME = 0.5f;
-*/
 
 const F32 MAX_VELOCITY_AUTO_LAND_SQUARED = 4.f * 4.f;
 
 const F32 MAX_FOCUS_OFFSET = 20.f;
 
-/*
-const F32 OBJECT_EXTENTS_PADDING = 0.5f;
-*/
-
 const F32 MIN_RADIUS_ALPHA_SIZZLE = 0.5f;
 
 const F64 CHAT_AGE_FAST_RATE = 3.0;
@@ -231,20 +184,12 @@ bool handleSlowMotionAnimation(const LLSD& newvalue)
 // LLAgent()
 //-----------------------------------------------------------------------------
 LLAgent::LLAgent() :
-	mDrawDistance( DEFAULT_FAR_PLANE ),
-
 	mGroupPowers(0),
 	mHideGroupTitle(FALSE),
 	mGroupID(),
 
-////	mLookAt(NULL),
-////	mPointAt(NULL),
-
-////	mHUDTargetZoom(1.f),
-////	mHUDCurZoom(1.f),
 	mInitialized(FALSE),
 	mListener(),
-////	mForceMouselook(FALSE),
 
 	mDoubleTapRunTimer(),
 	mDoubleTapRunMode(DOUBLETAP_NONE),
@@ -267,48 +212,10 @@ LLAgent::LLAgent() :
 	mRenderState(0),
 	mTypingTimer(),
 
-////	mCameraMode( CAMERA_MODE_THIRD_PERSON ),
-////	mLastCameraMode( CAMERA_MODE_THIRD_PERSON ),
 	mViewsPushed(FALSE),
 
-////	mCameraPreset(CAMERA_PRESET_REAR_VIEW),
-
 	mCustomAnim(FALSE),
 	mShowAvatar(TRUE),
-////	mCameraAnimating( FALSE ),
-////	mAnimationCameraStartGlobal(),
-////	mAnimationFocusStartGlobal(),
-////	mAnimationTimer(),
-////	mAnimationDuration(0.33f),
-	
-////	mCameraFOVZoomFactor(0.f),
-////	mCameraCurrentFOVZoomFactor(0.f),
-////	mCameraFocusOffset(),
-////	mCameraFOVDefault(DEFAULT_FIELD_OF_VIEW),
-
-////	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),
-////	mFocusGlobal(),
-////	mFocusTargetGlobal(),
-////	mFocusObject(NULL),
-////	mFocusObjectDist(0.f),
-////	mFocusObjectOffset(),
-////	mFocusDotRadius( 0.1f ),			// meters
-////	mTrackFocusObject(TRUE),
-//	mUIOffset(0.f),
-
 	mFrameAgent(),
 
 	mIsBusy(FALSE),
@@ -320,20 +227,6 @@ LLAgent::LLAgent() :
 	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),
-
 	mControlFlags(0x00000000),
 	mbFlagsDirty(FALSE),
 	mbFlagsNeedReset(FALSE),
@@ -371,7 +264,6 @@ LLAgent::LLAgent() :
 		mControlsTakenPassedOnCount[i] = 0;
 	}
 
-////	mFollowCam.setMaxCameraDistantFromSubject( MAX_CAMERA_DISTANCE_FROM_AGENT );
 
 	mListener.reset(new LLAgentListener(*this));
 }
@@ -385,39 +277,10 @@ void LLAgent::init()
 	gSavedSettings.declareBOOL("SlowMotionAnimation", FALSE, "Declared in code", FALSE);
 	gSavedSettings.getControl("SlowMotionAnimation")->getSignal()->connect(boost::bind(&handleSlowMotionAnimation, _2));
 	
-	mDrawDistance = gSavedSettings.getF32("RenderFarClip");
-
 	// *Note: this is where LLViewerCamera::getInstance() used to be constructed.
 
 	setFlying( gSavedSettings.getBOOL("FlyingAtExit") );
 
-/*
-	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("CameraPreset");
-
-////	mCameraOffsetInitial[CAMERA_PRESET_REAR_VIEW] = gSavedSettings.getVector3("CameraOffsetRearView");
-////	mCameraOffsetInitial[CAMERA_PRESET_FRONT_VIEW] = gSavedSettings.getVector3("CameraOffsetFrontView");
-////	mCameraOffsetInitial[CAMERA_PRESET_GROUP_VIEW] = gSavedSettings.getVector3("CameraOffsetGroupView");
-
-////	mFocusOffsetInitial[CAMERA_PRESET_REAR_VIEW] = gSavedSettings.getVector3d("FocusOffsetRearView");
-////	mFocusOffsetInitial[CAMERA_PRESET_FRONT_VIEW] = gSavedSettings.getVector3d("FocusOffsetFrontView");
-////	mFocusOffsetInitial[CAMERA_PRESET_GROUP_VIEW] = gSavedSettings.getVector3d("FocusOffsetGroupView");
-
-////	mCameraCollidePlane.clearVec();
-////	mCurrentCameraDistance = getCameraOffsetInitial().magVec() * gSavedSettings.getF32("CameraOffsetScale");
-////	mTargetCameraDistance = mCurrentCameraDistance;
-////	mCameraZoomFraction = 1.f;
-////	mTrackFocusObject = gSavedSettings.getBOOL("TrackFocusObject");
-*/
-
 	mEffectColor = LLUIColorTable::instance().getColor("EffectColor");
 
 	gSavedSettings.getControl("PreferredMaturity")->getValidateSignal()->connect(boost::bind(&LLAgent::validateMaturity, this, _2));
@@ -433,7 +296,7 @@ void LLAgent::cleanup()
 {
 	mAvatarObject = NULL;
 	mRegionp = NULL;
-	gAgentCameraHACK.cleanup();
+	gAgentCamera.cleanup();
 }
 
 //-----------------------------------------------------------------------------
@@ -446,85 +309,6 @@ LLAgent::~LLAgent()
 	// *Note: this is where LLViewerCamera::getInstance() used to be deleted.
 }
 
-/*
-// Change camera back to third person, stop the autopilot,
-// deselect stuff, etc.
-//-----------------------------------------------------------------------------
-// resetView()
-//-----------------------------------------------------------------------------
-void LLAgent::resetView(BOOL reset_camera, BOOL change_camera)
-{
-	if (mAutoPilot)
-	{
-		stopAutoPilot(TRUE);
-	}
-
-	if (!gNoRender)
-	{
-		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();
-		}
-
-		// 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 = getAtAxis();
-			agent_at_axis -= projected_vec(agent_at_axis, getReferenceUpVector());
-			agent_at_axis.normalize();
-			gAgent.resetAxes(lerp(getAtAxis(), agent_at_axis, LLCriticalDamp::getInterpolant(0.3f)));
-		}
-
-		setFocusOnAvatar(TRUE, ANIMATE);
-
-		mCameraFOVZoomFactor = 0.f;
-	}
-
-	mHUDTargetZoom = 1.f;
-}
-*/
-
 // Handle any actions that need to be performed when the main app gains focus
 // (such as through alt-tab).
 //-----------------------------------------------------------------------------
@@ -532,9 +316,9 @@ void LLAgent::resetView(BOOL reset_camera, BOOL change_camera)
 //-----------------------------------------------------------------------------
 void LLAgent::onAppFocusGained()
 {
-	if (CAMERA_MODE_MOUSELOOK == gAgentCameraHACK.mCameraMode)
+	if (CAMERA_MODE_MOUSELOOK == gAgentCamera.mCameraMode)
 	{
-		gAgentCameraHACK.changeCameraToDefault();
+		gAgentCamera.changeCameraToDefault();
 		LLToolMgr::getInstance()->clearSavedTool();
 	}
 }
@@ -551,24 +335,6 @@ void LLAgent::ageChat()
 	}
 }
 
-/*
-// Allow camera to be moved somewhere other than behind avatar.
-//-----------------------------------------------------------------------------
-// unlockView()
-//-----------------------------------------------------------------------------
-void LLAgent::unlockView()
-{
-	if (getFocusOnAvatar())
-	{
-		if (mAvatarObject.notNull())
-		{
-			setFocusGlobal( LLVector3d::zero, mAvatarObject->mID );
-		}
-		setFocusOnAvatar(FALSE, FALSE);	// no animation
-	}
-}
-*/
-
 //-----------------------------------------------------------------------------
 // moveAt()
 //-----------------------------------------------------------------------------
@@ -590,7 +356,7 @@ void LLAgent::moveAt(S32 direction, bool reset)
 
 	if (reset)
 	{
-		gAgentCameraHACK.resetView();
+		gAgentCamera.resetView();
 	}
 }
 
@@ -613,7 +379,7 @@ void LLAgent::moveAtNudge(S32 direction)
 		setControlFlags(AGENT_CONTROL_NUDGE_AT_NEG);
 	}
 
-	gAgentCameraHACK.resetView();
+	gAgentCamera.resetView();
 }
 
 //-----------------------------------------------------------------------------
@@ -635,7 +401,7 @@ void LLAgent::moveLeft(S32 direction)
 		setControlFlags(AGENT_CONTROL_LEFT_NEG | AGENT_CONTROL_FAST_LEFT);
 	}
 
-	gAgentCameraHACK.resetView();
+	gAgentCamera.resetView();
 }
 
 //-----------------------------------------------------------------------------
@@ -657,7 +423,7 @@ void LLAgent::moveLeftNudge(S32 direction)
 		setControlFlags(AGENT_CONTROL_NUDGE_LEFT_NEG);
 	}
 
-	gAgentCameraHACK.resetView();
+	gAgentCamera.resetView();
 }
 
 //-----------------------------------------------------------------------------
@@ -679,7 +445,7 @@ void LLAgent::moveUp(S32 direction)
 		setControlFlags(AGENT_CONTROL_UP_NEG | AGENT_CONTROL_FAST_UP);
 	}
 
-	gAgentCameraHACK.resetView();
+	gAgentCamera.resetView();
 }
 
 //-----------------------------------------------------------------------------
@@ -700,7 +466,7 @@ void LLAgent::moveYaw(F32 mag, bool reset_view)
 
     if (reset_view)
 	{
-        gAgentCameraHACK.resetView();
+        gAgentCamera.resetView();
 	}
 }
 
@@ -811,7 +577,7 @@ void LLAgent::toggleFlying()
 	BOOL fly = !gAgent.getFlying();
 
 	gAgent.setFlying( fly );
-	gAgentCameraHACK.resetView();
+	gAgentCamera.resetView();
 }
 
 // static
@@ -883,8 +649,7 @@ void LLAgent::setRegion(LLViewerRegion *regionp)
 			LLVector3 delta;
 			delta.setVec(regionp->getOriginGlobal());
 
-			setPositionAgent
-(getPositionAgent() - delta);
+			setPositionAgent(getPositionAgent() - delta);
 			LLVector3 camera_position_agent = LLViewerCamera::getInstance()->getOrigin();
 			LLViewerCamera::getInstance()->setOrigin(camera_position_agent - delta);
 
@@ -1034,19 +799,6 @@ void LLAgent::setPositionAgent(const LLVector3 &pos_agent)
 	}
 }
 
-/*
-//-----------------------------------------------------------------------------
-// slamLookAt()
-//-----------------------------------------------------------------------------
-void LLAgent::slamLookAt(const LLVector3 &look_at)
-{
-	LLVector3 look_at_norm = look_at;
-	look_at_norm.mV[VZ] = 0.f;
-	look_at_norm.normalize();
-	resetAxes(look_at_norm);
-}
-*/
-
 //-----------------------------------------------------------------------------
 // getPositionGlobal()
 //-----------------------------------------------------------------------------
@@ -1201,7 +953,7 @@ LLVector3 LLAgent::getReferenceUpVector()
 		mAvatarObject->getParent() &&
 		mAvatarObject->mDrawable.notNull())
 	{
-		U32 camera_mode = gAgentCameraHACK.mCameraAnimating ? gAgentCameraHACK.mLastCameraMode : gAgentCameraHACK.mCameraMode;
+		U32 camera_mode = gAgentCamera.mCameraAnimating ? gAgentCamera.mLastCameraMode : gAgentCamera.mCameraMode;
 		// and in third person...
 		if (camera_mode == CAMERA_MODE_THIRD_PERSON)
 		{
@@ -1300,699 +1052,6 @@ LLQuaternion LLAgent::getQuat() const
 	return mFrameAgent.getQuaternion();
 }
 
-/*
-//-----------------------------------------------------------------------------
-// calcFocusOffset()
-//-----------------------------------------------------------------------------
-LLVector3 LLAgent::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();
-
-	BOOL is_avatar = object->isAvatar();
-	// if is avatar - don't do any funk heuristics to position the focal point
-	// see DEV-30589
-	if (is_avatar)
-	{
-		return original_focus_point - obj_pos;
-	}
-
-	
-	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"
-	if (!is_avatar) 
-	{
-		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 LLAgent::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())
-	{
-		obj_min_distance = 0.f;
-		return TRUE;
-	}
-
-	if (mFocusObject->mDrawable.isNull())
-	{
-#ifdef LL_RELEASE_FOR_DOWNLOAD
-		llwarns << "Focus object with no drawable!" << llendl;
-#else
-		mFocusObject->dump();
-		llerrs << "Focus object with no drawable!" << llendl;
-#endif
-		obj_min_distance = 0.f;
-		return TRUE;
-	}
-	
-	LLQuaternion inv_object_rot = ~mFocusObject->getRenderRotation();
-	LLVector3 target_offset_origin = mFocusObjectOffset;
-	LLVector3 camera_offset_target(getCameraPositionAgent() - 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;
-	F32 object_radius = mFocusObject->getVObjRadius();
-
-	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());
-
-	// length projected orthogonal to target offset
-	F32 camera_offset_dist = (camera_offset_object - target_offset_dir * (camera_offset_object * target_offset_dir)).magVec();
-
-	// calculate whether the target point would be "visible" if it were outside the bounding box
-	// on the opposite of the splitting plane defined by object_split_axis;
-	BOOL exterior_target_visible = FALSE;
-	if (camera_offset_dist > object_radius)
-	{
-		// target is visible from camera, so turn off fov zoom
-		exterior_target_visible = TRUE;
-	}
-
-	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 LLAgent::getCameraZoomFraction()
-{
-	// 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;
-	}
-	else if (mFocusOnAvatar && cameraThirdPerson())
-	{
-		return clamp_rescale(mCameraZoomFraction, MIN_ZOOM_FRACTION, MAX_ZOOM_FRACTION, 1.f, 0.f);
-	}
-	else if (cameraCustomizeAvatar())
-	{
-		F32 distance = (F32)mCameraFocusOffsetTarget.magVec();
-		return clamp_rescale(distance, APPEARANCE_MIN_ZOOM, APPEARANCE_MAX_ZOOM, 1.f, 0.f );
-	}
-	else
-	{
-		F32 min_zoom;
-		const F32 DIST_FUDGE = 16.f; // meters
-		F32 max_zoom = llmin(mDrawDistance - DIST_FUDGE, 
-								LLWorld::getInstance()->getRegionWidthInMeters() - DIST_FUDGE,
-								MAX_CAMERA_DISTANCE_FROM_AGENT);
-
-		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 LLAgent::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;
-		const F32 DIST_FUDGE = 16.f; // meters
-		F32 max_zoom = llmin(mDrawDistance - DIST_FUDGE, 
-								LLWorld::getInstance()->getRegionWidthInMeters() - DIST_FUDGE,
-								MAX_CAMERA_DISTANCE_FROM_AGENT);
-
-		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();
-}
-
-
-//-----------------------------------------------------------------------------
-// cameraOrbitAround()
-//-----------------------------------------------------------------------------
-void LLAgent::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))
-	{
-		mFrameAgent.rotate(radians, getReferenceUpVector());
-	}
-	else
-	{
-		mCameraFocusOffsetTarget.rotVec(radians, 0.f, 0.f, 1.f);
-		
-		cameraZoomIn(1.f);
-	}
-}
-
-
-//-----------------------------------------------------------------------------
-// cameraOrbitOver()
-//-----------------------------------------------------------------------------
-void LLAgent::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)
-	{
-		pitch(angle);
-	}
-	else
-	{
-		LLVector3 camera_offset_unit(mCameraFocusOffsetTarget);
-		camera_offset_unit.normalize();
-
-		F32 angle_from_up = acos( camera_offset_unit * 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);
-		mCameraFocusOffsetTarget.rotVec(angle_from_up - new_angle, left_axis);
-
-		cameraZoomIn(1.f);
-	}
-}
-
-//-----------------------------------------------------------------------------
-// cameraZoomIn()
-//-----------------------------------------------------------------------------
-void LLAgent::cameraZoomIn(const F32 fraction)
-{
-	if (gDisconnected)
-	{
-		return;
-	}
-
-	LLObjectSelectionHandle selection = LLSelectMgr::getInstance()->getSelection();
-	if (selection->getObjectCount() && selection->getSelectType() == SELECT_TYPE_HUD)
-	{
-		// just update hud zoom level
-		mHUDTargetZoom /= fraction;
-		return;
-	}
-
-
-	LLVector3d	camera_offset(mCameraFocusOffsetTarget);
-	LLVector3d	camera_offset_unit(mCameraFocusOffsetTarget);
-	F32 min_zoom = LAND_MIN_ZOOM;
-	F32 current_distance = (F32)camera_offset_unit.normalize();
-	F32 new_distance = current_distance * fraction;
-
-	// 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); 
-
-	// Don't zoom too far back
-	const F32 DIST_FUDGE = 16.f; // meters
-	F32 max_distance = llmin(mDrawDistance - DIST_FUDGE, 
-							 LLWorld::getInstance()->getRegionWidthInMeters() - DIST_FUDGE );
-
-	if (new_distance > max_distance)
-	{
-		new_distance = max_distance;
-
-		// Unless camera is unlocked
-		//if (!LLViewerCamera::sDisableCameraConstraints)
-		//{
-		//	return;
-		//}
-	}
-
-	if( cameraCustomizeAvatar() )
-	{
-		new_distance = llclamp( new_distance, APPEARANCE_MIN_ZOOM, APPEARANCE_MAX_ZOOM );
-	}
-
-	mCameraFocusOffsetTarget = new_distance * camera_offset_unit;
-}
-
-//-----------------------------------------------------------------------------
-// cameraOrbitIn()
-//-----------------------------------------------------------------------------
-void LLAgent::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);
-		}
-
-		mCameraZoomFraction = llclamp(mCameraZoomFraction, MIN_ZOOM_FRACTION, MAX_ZOOM_FRACTION);
-	}
-	else
-	{
-		LLVector3d	camera_offset(mCameraFocusOffsetTarget);
-		LLVector3d	camera_offset_unit(mCameraFocusOffsetTarget);
-		F32 current_distance = (F32)camera_offset_unit.normalize();
-		F32 new_distance = current_distance - meters;
-		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);
-
-		// Don't zoom too far back
-		const F32 DIST_FUDGE = 16.f; // meters
-		F32 max_distance = llmin(mDrawDistance - DIST_FUDGE, 
-								 LLWorld::getInstance()->getRegionWidthInMeters() - DIST_FUDGE );
-
-		if (new_distance > max_distance)
-		{
-			// Unless camera is unlocked
-			if (!gSavedSettings.getBOOL("DisableCameraConstraints"))
-			{
-				return;
-			}
-		}
-
-		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 LLAgent::cameraPanIn(F32 meters)
-{
-	LLVector3d at_axis;
-	at_axis.setVec(LLViewerCamera::getInstance()->getAtAxis());
-
-	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 LLAgent::cameraPanLeft(F32 meters)
-{
-	LLVector3d left_axis;
-	left_axis.setVec(LLViewerCamera::getInstance()->getLeftAxis());
-
-	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 LLAgent::cameraPanUp(F32 meters)
-{
-	LLVector3d up_axis;
-	up_axis.setVec(LLViewerCamera::getInstance()->getUpAxis());
-
-	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();
-}
-*/
-
 //-----------------------------------------------------------------------------
 // setKey()
 //-----------------------------------------------------------------------------
@@ -2553,82 +1612,8 @@ void LLAgent::updateAgentPosition(const F32 dt, const F32 yaw_radians, const S32
 	// Check for water and land collision, set underwater flag
 	//
 
-	gAgentCameraHACK.updateLookAt(mouse_x, mouse_y);
-}
-
-/*
-//-----------------------------------------------------------------------------
-// updateLookAt()
-//-----------------------------------------------------------------------------
-void LLAgent::updateLookAt(const S32 mouse_x, const S32 mouse_y)
-{
-	static LLVector3 last_at_axis;
-
-
-	if (mAvatarObject.isNull())
-	{
-		return;
-	}
-
-	LLQuaternion av_inv_rot = ~mAvatarObject->mRoot.getWorldRotation();
-	LLVector3 root_at = LLVector3::x_axis * mAvatarObject->mRoot.getWorldRotation();
-
-	if 	((gViewerWindow->getMouseVelocityStat()->getCurrent() < 0.01f) &&
-		(root_at * last_at_axis > 0.95f ))
-	{
-		LLVector3 vel = mAvatarObject->getVelocity();
-		if (vel.magVecSquared() > 4.f)
-		{
-			setLookAt(LOOKAT_TARGET_IDLE, mAvatarObject, vel * av_inv_rot);
-		}
-		else
-		{
-			// *FIX: rotate mframeagent by sit object's rotation?
-			LLQuaternion look_rotation = mAvatarObject->isSitting() ? mAvatarObject->getRenderRotation() : mFrameAgent.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, mAvatarObject, look_offset);
-		}
-		last_at_axis = root_at;
-		return;
-	}
-
-	last_at_axis = root_at;
-	
-	if (CAMERA_MODE_CUSTOMIZE_AVATAR == getCameraMode())
-	{
-		setLookAt(LOOKAT_TARGET_NONE, mAvatarObject, 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->getWindowWidthScaled() ) - 0.5f;
-			F32 y_from_center = 
-				((F32) mouse_y / (F32) gViewerWindow->getWindowHeightScaled() ) - 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, mAvatarObject, headLookAxis);
-	}
+	gAgentCamera.updateLookAt(mouse_x, mouse_y);
 }
-*/
 
 // friends and operators
 
@@ -2661,22 +1646,22 @@ void LLAgent::setAvatarObject(LLVOAvatarSelf *avatar)
 		return;
 	}
 
-	if (!gAgentCameraHACK.mLookAt)
+	if (!gAgentCamera.mLookAt)
 	{
-		gAgentCameraHACK.mLookAt = (LLHUDEffectLookAt *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_LOOKAT);
+		gAgentCamera.mLookAt = (LLHUDEffectLookAt *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_LOOKAT);
 	}
-	if (!gAgentCameraHACK.mPointAt)
+	if (!gAgentCamera.mPointAt)
 	{
-		gAgentCameraHACK.mPointAt = (LLHUDEffectPointAt *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_POINTAT);
+		gAgentCamera.mPointAt = (LLHUDEffectPointAt *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_POINTAT);
 	}
 	
-	if (!gAgentCameraHACK.mLookAt.isNull())
+	if (!gAgentCamera.mLookAt.isNull())
 	{
-		gAgentCameraHACK.mLookAt->setSourceObject(avatar);
+		gAgentCamera.mLookAt->setSourceObject(avatar);
 	}
-	if (!gAgentCameraHACK.mPointAt.isNull())
+	if (!gAgentCamera.mPointAt.isNull())
 	{
-		gAgentCameraHACK.mPointAt->setSourceObject(avatar);
+		gAgentCamera.mPointAt->setSourceObject(avatar);
 	}
 }
 
@@ -2687,7 +1672,7 @@ void LLAgent::setAvatarObject(LLVOAvatarSelf *avatar)
 //-----------------------------------------------------------------------------
 BOOL LLAgent::needsRenderAvatar()
 {
-	if (gAgentCameraHACK.cameraMouselook() && !LLVOAvatar::sVisibleInFirstPerson)
+	if (gAgentCamera.cameraMouselook() && !LLVOAvatar::sVisibleInFirstPerson)
 	{
 		return FALSE;
 	}
@@ -2698,7 +1683,7 @@ BOOL LLAgent::needsRenderAvatar()
 // TRUE if we need to render your own avatar's head.
 BOOL LLAgent::needsRenderHead()
 {
-	return (LLVOAvatar::sVisibleInFirstPerson && LLPipeline::sReflectionRender) || (mShowAvatar && !gAgentCameraHACK.cameraMouselook());
+	return (LLVOAvatar::sVisibleInFirstPerson && LLPipeline::sReflectionRender) || (mShowAvatar && !gAgentCamera.cameraMouselook());
 }
 
 //-----------------------------------------------------------------------------
@@ -2720,7 +1705,7 @@ void LLAgent::startTyping()
 		LLViewerObject* chatter = gObjectList.findObject(mLastChatterID);
 		if (chatter && chatter->isAvatar())
 		{
-			gAgentCameraHACK.setLookAt(LOOKAT_TARGET_RESPOND, chatter, LLVector3::zero);
+			gAgentCamera.setLookAt(LOOKAT_TARGET_RESPOND, chatter, LLVector3::zero);
 		}
 	}
 
@@ -2799,14 +1784,14 @@ U8 LLAgent::getRenderState()
 //-----------------------------------------------------------------------------
 void LLAgent::endAnimationUpdateUI()
 {
-	if (gAgentCameraHACK.mCameraMode == gAgentCameraHACK.mLastCameraMode)
+	if (gAgentCamera.mCameraMode == gAgentCamera.mLastCameraMode)
 	{
 		// We're already done endAnimationUpdateUI for this transition.
 		return;
 	}
 
 	// clean up UI from mode we're leaving
-	if (gAgentCameraHACK.mLastCameraMode == CAMERA_MODE_MOUSELOOK )
+	if (gAgentCamera.mLastCameraMode == CAMERA_MODE_MOUSELOOK )
 	{
 		// show mouse cursor
 		gViewerWindow->showCursor();
@@ -2844,7 +1829,7 @@ void LLAgent::endAnimationUpdateUI()
 		}
 
 		
-		gAgentCameraHACK.setLookAt(LOOKAT_TARGET_CLEAR);
+		gAgentCamera.setLookAt(LOOKAT_TARGET_CLEAR);
 		if( gMorphView )
 		{
 			gMorphView->setVisible( FALSE );
@@ -2879,7 +1864,7 @@ void LLAgent::endAnimationUpdateUI()
 		}
 	}
 	else
-	if(gAgentCameraHACK.mLastCameraMode == CAMERA_MODE_CUSTOMIZE_AVATAR)
+	if(gAgentCamera.mLastCameraMode == CAMERA_MODE_CUSTOMIZE_AVATAR)
 	{
 		// make sure we ask to save changes
 
@@ -2901,13 +1886,13 @@ void LLAgent::endAnimationUpdateUI()
 			}
 			
 		}
-		gAgentCameraHACK.setLookAt(LOOKAT_TARGET_CLEAR);
+		gAgentCamera.setLookAt(LOOKAT_TARGET_CLEAR);
 	}
 
 	//---------------------------------------------------------------------
 	// Set up UI for mode we're entering
 	//---------------------------------------------------------------------
-	if (gAgentCameraHACK.mCameraMode == CAMERA_MODE_MOUSELOOK)
+	if (gAgentCamera.mCameraMode == CAMERA_MODE_MOUSELOOK)
 	{
 		// hide menus
 		gMenuBarView->setVisible(FALSE);
@@ -2922,7 +1907,7 @@ void LLAgent::endAnimationUpdateUI()
 		LLPanelStandStopFlying::getInstance()->setVisible(FALSE);
 
 		// clear out camera lag effect
-		gAgentCameraHACK.mCameraLag.clearVec();
+		gAgentCamera.mCameraLag.clearVec();
 
 		// JC - Added for always chat in third person option
 		gFocusMgr.setKeyboardFocus(NULL);
@@ -2992,7 +1977,7 @@ void LLAgent::endAnimationUpdateUI()
 		}
 
 	}
-	else if (gAgentCameraHACK.mCameraMode == CAMERA_MODE_CUSTOMIZE_AVATAR)
+	else if (gAgentCamera.mCameraMode == CAMERA_MODE_CUSTOMIZE_AVATAR)
 	{
 		LLToolMgr::getInstance()->setCurrentToolset(gFaceEditToolset);
 
@@ -3010,1581 +1995,17 @@ void LLAgent::endAnimationUpdateUI()
 
 	if (getAvatarObject())
 	{
-		getAvatarObject()->updateAttachmentVisibility(gAgentCameraHACK.mCameraMode);
+		getAvatarObject()->updateAttachmentVisibility(gAgentCamera.mCameraMode);
 	}
 
 	gFloaterTools->dirty();
 
 	// Don't let this be called more than once if the camera
 	// mode hasn't changed.  --JC
-	gAgentCameraHACK.mLastCameraMode = gAgentCameraHACK.mCameraMode;
+	gAgentCamera.mLastCameraMode = gAgentCamera.mCameraMode;
 
 }
 
-/*
-//-----------------------------------------------------------------------------
-// updateCamera()
-//-----------------------------------------------------------------------------
-void LLAgent::updateCamera()
-{
-	static LLFastTimer::DeclareTimer ftm("Camera");
-	LLFastTimer t(ftm);
-
-	//Ventrella - changed camera_skyward to the new global "mCameraUpVector"
-	mCameraUpVector = LLVector3::z_axis;
-	//LLVector3	camera_skyward(0.f, 0.f, 1.f);
-	//end Ventrella
-
-	U32 camera_mode = mCameraAnimating ? mLastCameraMode : mCameraMode;
-
-	validateFocusObject();
-
-	if (mAvatarObject.notNull() && 
-		mAvatarObject->isSitting() &&
-		camera_mode == CAMERA_MODE_MOUSELOOK)
-	{
-		//Ventrella
-		//changed camera_skyward to the new global "mCameraUpVector"
-		mCameraUpVector = mCameraUpVector * mAvatarObject->getRenderRotation();
-		//end Ventrella
-	}
-
-	if (cameraThirdPerson() && mFocusOnAvatar && LLFollowCamMgr::getActiveFollowCamParams())
-	{
-		changeCameraToFollow();
-	}
-
-	//Ventrella
-	//NOTE - this needs to be integrated into a general upVector system here within llAgent. 
-	if ( camera_mode == CAMERA_MODE_FOLLOW && mFocusOnAvatar )
-	{
-		mCameraUpVector = mFollowCam.getUpVector();
-	}
-	//end Ventrella
-
-	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(
-		mOrbitRightKey > 0.f,	// left
-		mOrbitUpKey > 0.f,		// top
-		mOrbitLeftKey > 0.f,	// right
-		mOrbitDownKey > 0.f);	// bottom
-
-		camera_floater->mTrack->setToggleState(
-		mPanLeftKey > 0.f,		// left
-		mPanUpKey > 0.f,		// top
-		mPanRightKey > 0.f,		// right
-		mPanDownKey > 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( mOrbitUpKey || mOrbitDownKey )
-	{
-		F32 input_rate = mOrbitUpKey - mOrbitDownKey;
-		cameraOrbitOver( input_rate * ORBIT_OVER_RATE / gFPSClamped );
-	}
-
-	if( mOrbitLeftKey || mOrbitRightKey)
-	{
-		F32 input_rate = mOrbitLeftKey - mOrbitRightKey;
-		cameraOrbitAround( input_rate * ORBIT_AROUND_RATE / gFPSClamped );
-	}
-
-	if( mOrbitInKey || mOrbitOutKey )
-	{
-		F32 input_rate = mOrbitInKey - mOrbitOutKey;
-		
-		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( mPanInKey || mPanOutKey )
-	{
-		F32 input_rate = mPanInKey - mPanOutKey;
-		cameraPanIn( input_rate * PAN_RATE / gFPSClamped );
-	}
-
-	if( mPanRightKey || mPanLeftKey )
-	{
-		F32 input_rate = mPanRightKey - mPanLeftKey;
-		cameraPanLeft( input_rate * -PAN_RATE / gFPSClamped );
-	}
-
-	if( mPanUpKey || mPanDownKey )
-	{
-		F32 input_rate = mPanUpKey - mPanDownKey;
-		cameraPanUp( input_rate * PAN_RATE / gFPSClamped );
-	}
-
-	// Clear camera keyboard keys.
-	mOrbitLeftKey		= 0.f;
-	mOrbitRightKey		= 0.f;
-	mOrbitUpKey			= 0.f;
-	mOrbitDownKey		= 0.f;
-	mOrbitInKey			= 0.f;
-	mOrbitOutKey		= 0.f;
-
-	mPanRightKey		= 0.f;
-	mPanLeftKey			= 0.f;
-	mPanUpKey			= 0.f;
-	mPanDownKey			= 0.f;
-	mPanInKey			= 0.f;
-	mPanOutKey			= 0.f;
-
-	// lerp camera focus offset
-	mCameraFocusOffset = lerp(mCameraFocusOffset, mCameraFocusOffsetTarget, LLCriticalDamp::getInterpolant(CAMERA_FOCUS_HALF_LIFE));
-
-	//Ventrella
-	if ( mCameraMode == CAMERA_MODE_FOLLOW )
-	{
-		if ( mAvatarObject.notNull() )
-		{
-			//--------------------------------------------------------------------------------
-			// 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 = mAvatarObject->isSitting() ? mAvatarObject->getRenderRotation() : mFrameAgent.getQuaternion();
-
-			LLFollowCamParams* current_cam = LLFollowCamMgr::getActiveFollowCamParams();
-			if (current_cam)
-			{
-				mFollowCam.copyParams(*current_cam);
-				mFollowCam.setSubjectPositionAndRotation( mAvatarObject->getRenderPosition(), avatarRotationForFollowCam );
-				mFollowCam.update();
-				LLViewerJoystick::getInstance()->setCameraNeedsUpdate(true);
-			}
-			else
-			{
-				changeCameraToThirdPerson(TRUE);
-			}
-		}
-	}
-	// end Ventrella
-
-	BOOL hit_limit;
-	LLVector3d camera_pos_global;
-	LLVector3d camera_target_global = calcCameraPositionTargetGlobal(&hit_limit);
-	mCameraVirtualPositionAgent = 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);
-
-	mShowAvatar = 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 )
-			{
-				mShowAvatar = 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;
-
-			endAnimationUpdateUI();
-			mShowAvatar = TRUE;
-		}
-
-		if (getAvatarObject() && mCameraMode != CAMERA_MODE_MOUSELOOK)
-		{
-			getAvatarObject()->updateAttachmentVisibility(mCameraMode);
-		}
-	}
-	else 
-	{
-		camera_pos_global = camera_target_global;
-		mFocusGlobal = focus_target_global;
-		mShowAvatar = TRUE;
-	}
-
-	// smoothing
-	if (TRUE)
-	{
-		LLVector3d agent_pos = 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
-		mCameraSmoothingStop |= (BOOL)LLToolMgr::getInstance()->inBuildMode();
-		
-		if (cameraThirdPerson() && !mCameraSmoothingStop)
-		{
-			const F32 SMOOTHING_HALF_LIFE = 0.02f;
-			
-			F32 smoothing = LLCriticalDamp::getInterpolant(gSavedSettings.getF32("CameraPositionSmoothing") * SMOOTHING_HALF_LIFE, FALSE);
-					
-			if (!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, LLCriticalDamp::getInterpolant(FOV_ZOOM_HALF_LIFE));
-
-//	llinfos << "Current FOV Zoom: " << mCameraCurrentFOVZoomFactor << " Target FOV Zoom: " << mCameraFOVZoomFactor << " Object penetration: " << mFocusObjectDist << llendl;
-
-	F32 ui_offset = 0.f;
-	if( CAMERA_MODE_CUSTOMIZE_AVATAR == mCameraMode ) 
-	{
-		ui_offset = calcCustomizeAvatarUIOffset( camera_pos_global );
-	}
-
-
-	LLVector3 focus_agent = getPosAgentFromGlobal(mFocusGlobal);
-	
-	mCameraPositionAgent	= getPosAgentFromGlobal(camera_pos_global);
-
-	// Move the camera
-
-	//Ventrella
-	LLViewerCamera::getInstance()->updateCameraLocation(mCameraPositionAgent, mCameraUpVector, focus_agent);
-	//LLViewerCamera::getInstance()->updateCameraLocation(mCameraPositionAgent, camera_skyward, focus_agent);
-	//end Ventrella
-
-	//RN: translate UI offset after camera is oriented properly
-	LLViewerCamera::getInstance()->translate(LLViewerCamera::getInstance()->getLeftAxis() * ui_offset);
-	
-	// 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 = getPositionGlobal(); 
-	if (! mLastPositionGlobal.isExactlyZero())
-	{
-		LLVector3d delta = global_pos - mLastPositionGlobal;
-		mDistanceTraveled += delta.magVec();
-	}
-	mLastPositionGlobal = global_pos;
-	
-	if (LLVOAvatar::sVisibleInFirstPerson && mAvatarObject.notNull() && !mAvatarObject->isSitting() && cameraMouselook())
-	{
-		LLVector3 head_pos = mAvatarObject->mHeadp->getWorldPosition() + 
-			LLVector3(0.08f, 0.f, 0.05f) * mAvatarObject->mHeadp->getWorldRotation() + 
-			LLVector3(0.1f, 0.f, 0.f) * mAvatarObject->mPelvisp->getWorldRotation();
-		LLVector3 diff = mCameraPositionAgent - head_pos;
-		diff = diff * ~mAvatarObject->mRoot.getWorldRotation();
-
-		LLJoint* torso_joint = mAvatarObject->mTorsop;
-		LLJoint* chest_joint = mAvatarObject->mChestp;
-		LLVector3 torso_scale = torso_joint->getScale();
-		LLVector3 chest_scale = chest_joint->getScale();
-
-		// shorten avatar skeleton to avoid foot interpenetration
-		if (!mAvatarObject->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 = mAvatarObject->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;
-		}
-
-		mAvatarObject->mPelvisp->setPosition(mAvatarObject->mPelvisp->getPosition() + diff);
-
-		mAvatarObject->mRoot.updateWorldMatrixChildren();
-
-		for (LLVOAvatar::attachment_map_t::iterator iter = mAvatarObject->mAttachmentPoints.begin(); 
-			 iter != mAvatarObject->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);
-				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 LLAgent::updateFocusOffset()
-{
-	validateFocusObject();
-	if (mFocusObject.notNull())
-	{
-		LLVector3d obj_pos = getPosGlobalFromAgent(mFocusObject->getRenderPosition());
-		mFocusObjectOffset.setVec(mFocusTargetGlobal - obj_pos);
-	}
-}
-
-void LLAgent::validateFocusObject()
-{
-	if (mFocusObject.notNull() && 
-		(mFocusObject->isDead()))
-	{
-		mFocusObjectOffset.clearVec();
-		clearFocusObject();
-		mCameraFOVZoomFactor = 0.f;
-	}
-}
-
-//-----------------------------------------------------------------------------
-// calcCustomizeAvatarUIOffset()
-//-----------------------------------------------------------------------------
-F32 LLAgent::calcCustomizeAvatarUIOffset( const LLVector3d& camera_pos_global )
-{
-	F32 ui_offset = 0.f;
-
-	if( gFloaterCustomize )
-	{
-		const LLRect& rect = gFloaterCustomize->getRect();
-
-		// Move the camera so that the avatar isn't covered up by this floater.
-		F32 fraction_of_fov = 0.5f - (0.5f * (1.f - llmin(1.f, ((F32)rect.getWidth() / (F32)gViewerWindow->getWindowWidthScaled()))));
-		F32 apparent_angle = fraction_of_fov * LLViewerCamera::getInstance()->getView() * LLViewerCamera::getInstance()->getAspect();  // radians
-		F32 offset = tan(apparent_angle);
-
-		if( rect.mLeft < (gViewerWindow->getWindowWidthScaled() - rect.mRight) )
-		{
-			// Move the avatar to the right (camera to the left)
-			ui_offset = offset;
-		}
-		else
-		{
-			// Move the avatar to the left (camera to the right)
-			ui_offset = -offset;
-		}
-	}
-	F32 range = (F32)dist_vec(camera_pos_global, gAgentCamera.getFocusGlobal());
-	gAgentCameraHACK.mUIOffset = lerp(mUIOffset, ui_offset, LLCriticalDamp::getInterpolant(0.05f));
-	return mUIOffset * range;
-}
-
-//-----------------------------------------------------------------------------
-// calcFocusPositionTargetGlobal()
-//-----------------------------------------------------------------------------
-LLVector3d LLAgent::calcFocusPositionTargetGlobal()
-{
-	if (mFocusObject.notNull() && mFocusObject->isDead())
-	{
-		clearFocusObject();
-	}
-
-	// Ventrella
-	if ( mCameraMode == CAMERA_MODE_FOLLOW && mFocusOnAvatar )
-	{
-		mFocusTargetGlobal = gAgent.getPosGlobalFromAgent(mFollowCam.getSimulatedFocus());
-		return mFocusTargetGlobal;
-	}// End Ventrella 
-	else if (mCameraMode == CAMERA_MODE_MOUSELOOK)
-	{
-		LLVector3d at_axis(1.0, 0.0, 0.0);
-		LLQuaternion agent_rot = mFrameAgent.getQuaternion();
-		if (mAvatarObject.notNull() && mAvatarObject->getParent())
-		{
-			LLViewerObject* root_object = (LLViewerObject*)mAvatarObject->getRoot();
-			if (!root_object->flagCameraDecoupled())
-			{
-				agent_rot *= ((LLViewerObject*)(mAvatarObject->getParent()))->getRenderRotation();
-			}
-		}
-		at_axis = at_axis * agent_rot;
-		mFocusTargetGlobal = calcCameraPositionTargetGlobal() + at_axis;
-		return mFocusTargetGlobal;
-	}
-	else if (mCameraMode == CAMERA_MODE_CUSTOMIZE_AVATAR)
-	{
-		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(getPosGlobalFromAgent(focus_agent));
-		}
-		return mFocusTargetGlobal;
-	}
-	else if (mSitCameraEnabled && mAvatarObject.notNull() && mAvatarObject->isSitting() && mSitCameraReferenceObject.notNull())
-	{
-		// sit camera
-		LLVector3 object_pos = mSitCameraReferenceObject->getRenderPosition();
-		LLQuaternion object_rot = mSitCameraReferenceObject->getRenderRotation();
-
-		LLVector3 target_pos = object_pos + (mSitCameraFocus * object_rot);
-		return getPosGlobalFromAgent(target_pos);
-	}
-	else
-	{
-		return getPositionGlobal() + calcThirdPersonFocusOffset();
-	}
-}
-
-LLVector3d LLAgent::calcThirdPersonFocusOffset()
-{
-	// ...offset from avatar
-	LLVector3d focus_offset;
-
-	LLQuaternion agent_rot = mFrameAgent.getQuaternion();
-	if (!mAvatarObject.isNull() && mAvatarObject->getParent())
-	{
-		agent_rot *= ((LLViewerObject*)(mAvatarObject->getParent()))->getRenderRotation();
-	}
-
-	focus_offset = mFocusOffsetInitial[mCameraPreset] * agent_rot;
-	return focus_offset;
-}
-
-void LLAgent::setupSitCamera()
-{
-	// agent frame entering this function is in world coordinates
-	if (mAvatarObject.notNull() && mAvatarObject->getParent())
-	{
-		LLQuaternion parent_rot = ((LLViewerObject*)mAvatarObject->getParent())->getRenderRotation();
-		// slam agent coordinate frame to proper parent local version
-		LLVector3 at_axis = mFrameAgent.getAtAxis();
-		at_axis.mV[VZ] = 0.f;
-		at_axis.normalize();
-		resetAxes(at_axis * ~parent_rot);
-	}
-}
-
-//-----------------------------------------------------------------------------
-// getCameraPositionAgent()
-//-----------------------------------------------------------------------------
-const LLVector3 &LLAgent::getCameraPositionAgent() const
-{
-	return LLViewerCamera::getInstance()->getOrigin();
-}
-
-//-----------------------------------------------------------------------------
-// getCameraPositionGlobal()
-//-----------------------------------------------------------------------------
-LLVector3d LLAgent::getCameraPositionGlobal() const
-{
-	return getPosGlobalFromAgent(LLViewerCamera::getInstance()->getOrigin());
-}
-
-//-----------------------------------------------------------------------------
-// calcCameraFOVZoomFactor()
-//-----------------------------------------------------------------------------
-F32	LLAgent::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
-		LLVector3 focus_offset = mFocusObjectOffset;
-		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 LLAgent::calcCameraPositionTargetGlobal(BOOL *hit_limit)
-{
-	// Compute base camera position and look-at points.
-	F32			camera_land_height;
-	LLVector3d	frame_center_global = mAvatarObject.isNull() ? getPositionGlobal() 
-															 : getPosGlobalFromAgent(mAvatarObject->mRoot.getWorldPosition());
-		
-	BOOL		isConstrained = FALSE;
-	LLVector3d	head_offset;
-	head_offset.setVec(mThirdPersonHeadOffset);
-
-	LLVector3d camera_position_global;
-
-	// Ventrella 
-	if ( mCameraMode == CAMERA_MODE_FOLLOW && mFocusOnAvatar )
-	{
-		camera_position_global = gAgent.getPosGlobalFromAgent(mFollowCam.getSimulatedPosition());
-	}// End Ventrella
-	else if (mCameraMode == CAMERA_MODE_MOUSELOOK)
-	{
-		if (mAvatarObject.isNull() || mAvatarObject->mDrawable.isNull())
-		{
-			llwarns << "Null avatar drawable!" << llendl;
-			return LLVector3d::zero;
-		}
-		head_offset.clearVec();
-		if (mAvatarObject->isSitting() && mAvatarObject->getParent())
-		{
-			mAvatarObject->updateHeadOffset();
-			head_offset.mdV[VX] = mAvatarObject->mHeadOffset.mV[VX];
-			head_offset.mdV[VY] = mAvatarObject->mHeadOffset.mV[VY];
-			head_offset.mdV[VZ] = mAvatarObject->mHeadOffset.mV[VZ] + 0.1f;
-			const LLMatrix4& mat = ((LLViewerObject*) mAvatarObject->getParent())->getRenderMatrix();
-			camera_position_global = getPosGlobalFromAgent
-								((mAvatarObject->getPosition()+
-								 LLVector3(head_offset)*mAvatarObject->getRotation()) * mat);
-		}
-		else
-		{
-			head_offset.mdV[VZ] = mAvatarObject->mHeadOffset.mV[VZ];
-			if (mAvatarObject->isSitting())
-			{
-				head_offset.mdV[VZ] += 0.1;
-			}
-			camera_position_global = getPosGlobalFromAgent(mAvatarObject->getRenderPosition());//frame_center_global;
-			head_offset = head_offset * mAvatarObject->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 
-			&& mAvatarObject.notNull() 
-			&& mAvatarObject->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 = getPosGlobalFromAgent(target_pos);
-		}
-		else
-		{
-			local_camera_offset = mCameraZoomFraction * getCameraOffsetInitial() * gSavedSettings.getF32("CameraOffsetScale");
-			
-			// are we sitting down?
-			if (mAvatarObject.notNull() && mAvatarObject->getParent())
-			{
-				LLQuaternion parent_rot = ((LLViewerObject*)mAvatarObject->getParent())->getRenderRotation();
-				// slam agent coordinate frame to proper parent local version
-				LLVector3 at_axis = mFrameAgent.getAtAxis() * parent_rot;
-				at_axis.mV[VZ] = 0.f;
-				at_axis.normalize();
-				resetAxes(at_axis * ~parent_rot);
-
-				local_camera_offset = local_camera_offset * mFrameAgent.getQuaternion() * parent_rot;
-			}
-			else
-			{
-				local_camera_offset = mFrameAgent.rotateToAbsolute( local_camera_offset );
-			}
-
-			if (!mCameraCollidePlane.isExactlyZero() && (mAvatarObject.isNull() || !mAvatarObject->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 = 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 = LLCriticalDamp::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;
-			
-			LLVector3 av_pos = mAvatarObject.isNull() ? LLVector3::zero : mAvatarObject->getRenderPosition();
-			camera_offset.setVec( local_camera_offset );
-			camera_position_global = frame_center_global + head_offset + camera_offset;
-
-			if (mAvatarObject.notNull())
-			{
-				LLVector3d camera_lag_d;
-				F32 lag_interp = LLCriticalDamp::getInterpolant(CAMERA_LAG_HALF_LIFE);
-				LLVector3 target_lag;
-				LLVector3 vel = getVelocity();
-
-				// lag by appropriate amount for flying
-				F32 time_in_air = mAvatarObject->mTimeInAir.getElapsedTimeF32();
-				if(!mCameraAnimating && mAvatarObject->mInAir && time_in_air > GROUND_TO_AIR_CAMERA_TRANSITION_START_TIME)
-				{
-					LLVector3 frame_at_axis = mFrameAgent.getAtAxis();
-					frame_at_axis -= projected_vec(frame_at_axis, 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 == mAvatarObject->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, LLCriticalDamp::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 (!gSavedSettings.getBOOL("DisableCameraConstraints") && !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);
-
-	if (camera_position_global.mdV[VZ] < camera_land_height + camera_min_off_ground)
-	{
-		camera_position_global.mdV[VZ] = camera_land_height + camera_min_off_ground;
-		isConstrained = TRUE;
-	}
-
-
-	if (hit_limit)
-	{
-		*hit_limit = isConstrained;
-	}
-
-	return camera_position_global;
-}
-
-
-LLVector3 LLAgent::getCameraOffsetInitial()
-{
-	return mCameraOffsetInitial[mCameraPreset];
-}
-
-//-----------------------------------------------------------------------------
-// handleScrollWheel()
-//-----------------------------------------------------------------------------
-void LLAgent::handleScrollWheel(S32 clicks)
-{
-	if ( mCameraMode == CAMERA_MODE_FOLLOW && gAgentCamera.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 LLAgent::getCameraMinOffGround()
-{
-	if (mCameraMode == CAMERA_MODE_MOUSELOOK)
-	{
-		return 0.f;
-	}
-	else
-	{
-		if (gSavedSettings.getBOOL("DisableCameraConstraints"))
-		{
-			return -1000.f;
-		}
-		else
-		{
-			return 0.5f;
-		}
-	}
-}
-
-
-//-----------------------------------------------------------------------------
-// resetCamera()
-//-----------------------------------------------------------------------------
-void LLAgent::resetCamera()
-{
-	// Remove any pitch from the avatar
-	LLVector3 at = mFrameAgent.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 LLAgent::changeCameraToMouselook(BOOL animate)
-{
-	if (LLViewerJoystick::getInstance()->getOverrideCamera())
-	{
-		return;
-	}
-
-	// visibility changes at end of animation
-	gViewerWindow->getWindow()->resetBusyCount();
-
-	// unpause avatar animation
-	mPauseRequest = NULL;
-
-	LLToolMgr::getInstance()->setCurrentToolset(gMouselookToolset);
-
-	if (mAvatarObject.notNull())
-	{
-		mAvatarObject->stopMotion( ANIM_AGENT_BODY_NOISE );
-		mAvatarObject->stopMotion( ANIM_AGENT_BREATHE_ROT );
-	}
-
-	//gViewerWindow->stopGrab();
-	LLSelectMgr::getInstance()->deselectAll();
-	gViewerWindow->hideCursor();
-	gViewerWindow->moveCursorToCenter();
-
-	if( mCameraMode != CAMERA_MODE_MOUSELOOK )
-	{
-		gFocusMgr.setKeyboardFocus( NULL );
-		
-		mLastCameraMode = mCameraMode;
-		mCameraMode = CAMERA_MODE_MOUSELOOK;
-		U32 old_flags = mControlFlags;
-		setControlFlags(AGENT_CONTROL_MOUSELOOK);
-		if (old_flags != mControlFlags)
-		{
-			mbFlagsDirty = TRUE;
-		}
-
-		if (animate)
-		{
-			startCameraAnimation();
-		}
-		else
-		{
-			mCameraAnimating = FALSE;
-			endAnimationUpdateUI();
-		}
-	}
-}
-
-
-//-----------------------------------------------------------------------------
-// changeCameraToDefault()
-//-----------------------------------------------------------------------------
-void LLAgent::changeCameraToDefault()
-{
-	if (LLViewerJoystick::getInstance()->getOverrideCamera())
-	{
-		return;
-	}
-
-	if (LLFollowCamMgr::getActiveFollowCamParams())
-	{
-		changeCameraToFollow();
-	}
-	else
-	{
-		changeCameraToThirdPerson();
-	}
-}
-
-
-// Ventrella
-//-----------------------------------------------------------------------------
-// changeCameraToFollow()
-//-----------------------------------------------------------------------------
-void LLAgent::changeCameraToFollow(BOOL animate)
-{
-	if (LLViewerJoystick::getInstance()->getOverrideCamera())
-	{
-		return;
-	}
-
-	if( mCameraMode != CAMERA_MODE_FOLLOW )
-	{
-		if (mCameraMode == CAMERA_MODE_MOUSELOOK)
-		{
-			animate = FALSE;
-		}
-		startCameraAnimation();
-
-		mLastCameraMode = mCameraMode;
-		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 (mAvatarObject.notNull())
-		{
-			mAvatarObject->mPelvisp->setPosition(LLVector3::zero);
-			mAvatarObject->startMotion( ANIM_AGENT_BODY_NOISE );
-			mAvatarObject->startMotion( ANIM_AGENT_BREATHE_ROT );
-		}
-
-		// unpause avatar animation
-		mPauseRequest = NULL;
-
-		U32 old_flags = mControlFlags;
-		clearControlFlags(AGENT_CONTROL_MOUSELOOK);
-		if (old_flags != mControlFlags)
-		{
-			mbFlagsDirty = TRUE;
-		}
-
-		if (animate)
-		{
-			startCameraAnimation();
-		}
-		else
-		{
-			mCameraAnimating = FALSE;
-			endAnimationUpdateUI();
-		}
-	}
-}
-
-//-----------------------------------------------------------------------------
-// changeCameraToThirdPerson()
-//-----------------------------------------------------------------------------
-void LLAgent::changeCameraToThirdPerson(BOOL animate)
-{
-	if (LLViewerJoystick::getInstance()->getOverrideCamera())
-	{
-		return;
-	}
-
-	gViewerWindow->getWindow()->resetBusyCount();
-
-	mCameraZoomFraction = INITIAL_ZOOM_FRACTION;
-
-	if (mAvatarObject.notNull())
-	{
-		if (!mAvatarObject->isSitting())
-		{
-			mAvatarObject->mPelvisp->setPosition(LLVector3::zero);
-		}
-		mAvatarObject->startMotion( ANIM_AGENT_BODY_NOISE );
-		mAvatarObject->startMotion( ANIM_AGENT_BREATHE_ROT );
-	}
-
-	LLVector3 at_axis;
-
-	// unpause avatar animation
-	mPauseRequest = NULL;
-
-	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;
-		}
-		mLastCameraMode = mCameraMode;
-		mCameraMode = CAMERA_MODE_THIRD_PERSON;
-		U32 old_flags = mControlFlags;
-		clearControlFlags(AGENT_CONTROL_MOUSELOOK);
-		if (old_flags != mControlFlags)
-		{
-			mbFlagsDirty = TRUE;
-		}
-
-	}
-
-	// Remove any pitch from the avatar
-	if (mAvatarObject.notNull() && mAvatarObject->getParent())
-	{
-		LLQuaternion obj_rot = ((LLViewerObject*)mAvatarObject->getParent())->getRenderRotation();
-		at_axis = LLViewerCamera::getInstance()->getAtAxis();
-		at_axis.mV[VZ] = 0.f;
-		at_axis.normalize();
-		resetAxes(at_axis * ~obj_rot);
-	}
-	else
-	{
-		at_axis = mFrameAgent.getAtAxis();
-		at_axis.mV[VZ] = 0.f;
-		at_axis.normalize();
-		resetAxes(at_axis);
-	}
-
-
-	if (animate)
-	{
-		startCameraAnimation();
-	}
-	else
-	{
-		mCameraAnimating = FALSE;
-		endAnimationUpdateUI();
-	}
-}
-
-//-----------------------------------------------------------------------------
-// changeCameraToCustomizeAvatar()
-//-----------------------------------------------------------------------------
-void LLAgent::changeCameraToCustomizeAvatar(BOOL avatar_animate, BOOL camera_animate)
-{
-	if (LLViewerJoystick::getInstance()->getOverrideCamera())
-	{
-		return;
-	}
-
-	standUp(); // force stand up
-	gViewerWindow->getWindow()->resetBusyCount();
-
-	if (gFaceEditToolset)
-	{
-		LLToolMgr::getInstance()->setCurrentToolset(gFaceEditToolset);
-	}
-
-	if (camera_animate)
-	{
-		startCameraAnimation();
-	}
-
-	// Remove any pitch from the avatar
-	//LLVector3 at = mFrameAgent.getAtAxis();
-	//at.mV[VZ] = 0.f;
-	//at.normalize();
-	//gAgent.resetAxes(at);
-
-	if( mCameraMode != CAMERA_MODE_CUSTOMIZE_AVATAR )
-	{
-		mLastCameraMode = mCameraMode;
-		mCameraMode = CAMERA_MODE_CUSTOMIZE_AVATAR;
-		U32 old_flags = mControlFlags;
-		clearControlFlags(AGENT_CONTROL_MOUSELOOK);
-		if (old_flags != mControlFlags)
-		{
-			mbFlagsDirty = TRUE;
-		}
-
-		gFocusMgr.setKeyboardFocus( NULL );
-		gFocusMgr.setMouseCapture( NULL );
-
-		LLVOAvatarSelf::onCustomizeStart();
-	}
-
-	if (mAvatarObject.notNull())
-	{
-		if(avatar_animate)
-		{
-			// Remove any pitch from the avatar
-			LLVector3 at = mFrameAgent.getAtAxis();
-			at.mV[VZ] = 0.f;
-			at.normalize();
-			gAgent.resetAxes(at);
-
-			sendAnimationRequest(ANIM_AGENT_CUSTOMIZE, ANIM_REQUEST_START);
-			mCustomAnim = TRUE ;
-			mAvatarObject->startMotion(ANIM_AGENT_CUSTOMIZE);
-			LLMotion* turn_motion = mAvatarObject->findMotion(ANIM_AGENT_CUSTOMIZE);
-
-			if (turn_motion)
-			{
-				mAnimationDuration = turn_motion->getDuration() + CUSTOMIZE_AVATAR_CAMERA_ANIM_SLOP;
-
-			}
-			else
-			{
-				mAnimationDuration = gSavedSettings.getF32("ZoomTime");
-			}
-		}
-
-
-
-		gAgentCamera.setFocusGlobal(LLVector3d::zero);
-	}
-	else
-	{
-		mCameraAnimating = FALSE;
-		endAnimationUpdateUI();
-	}
-
-}
-
-
-void LLAgent::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;
-
-	gSavedSettings.setU32("CameraPreset", mCameraPreset);
-}
-
-
-//
-// Focus point management
-//
-
-//-----------------------------------------------------------------------------
-// startCameraAnimation()
-//-----------------------------------------------------------------------------
-void LLAgent::startCameraAnimation()
-{
-	mAnimationCameraStartGlobal = getCameraPositionGlobal();
-	mAnimationFocusStartGlobal = mFocusGlobal;
-	mAnimationTimer.reset();
-	mCameraAnimating = TRUE;
-	mAnimationDuration = gSavedSettings.getF32("ZoomTime");
-}
-
-//-----------------------------------------------------------------------------
-// stopCameraAnimation()
-//-----------------------------------------------------------------------------
-void LLAgent::stopCameraAnimation()
-{
-	mCameraAnimating = FALSE;
-}
-
-void LLAgent::clearFocusObject()
-{
-	if (mFocusObject.notNull())
-	{
-		startCameraAnimation();
-
-		setFocusObject(NULL);
-		mFocusObjectOffset.clearVec();
-	}
-}
-
-void LLAgent::setFocusObject(LLViewerObject* object)
-{
-	mFocusObject = object;
-}
-
-// Focus on a point, but try to keep camera position stable.
-//-----------------------------------------------------------------------------
-// setFocusGlobal()
-//-----------------------------------------------------------------------------
-void LLAgent::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 LLAgent::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 (mAvatarObject.notNull())
-			{
-				mFocusTargetGlobal = getPosGlobalFromAgent(mAvatarObject->mHeadp->getWorldPosition());
-			}
-			else
-			{
-				mFocusTargetGlobal = 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, (getPosAgentFromGlobal(focus) - focus_obj->getRenderPosition()) * ~focus_obj->getRenderRotation());
-				}
-			}
-			else
-			{
-				setLookAt(LOOKAT_TARGET_FOCUS, NULL, getPosAgentFromGlobal(mFocusTargetGlobal));
-			}
-		}
-	}
-	else // focus == mFocusTargetGlobal
-	{
-		if (focus.isExactlyZero())
-		{
-			if (mAvatarObject.notNull())
-			{
-				mFocusTargetGlobal = getPosGlobalFromAgent(mAvatarObject->mHeadp->getWorldPosition());
-			}
-			else
-			{
-				mFocusTargetGlobal = 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()		// DEV-29123 - can crash with a messed-up attachment
-				&& !mFocusObject->isAvatar())
-			{
-				mFocusObject = (LLViewerObject*) mFocusObject->getParent();
-			}
-			setFocusObject((LLViewerObject*)mFocusObject);
-		}
-		updateFocusOffset();
-	}
-}
-
-// Used for avatar customization
-//-----------------------------------------------------------------------------
-// setCameraPosAndFocusGlobal()
-//-----------------------------------------------------------------------------
-void LLAgent::setCameraPosAndFocusGlobal(const LLVector3d& camera_pos, const LLVector3d& focus, const LLUUID &object_id)
-{
-	LLVector3d old_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();
-
-		if( CAMERA_MODE_CUSTOMIZE_AVATAR == mCameraMode ) 
-		{
-			// Compensate for the fact that the camera has already been offset to make room for LLFloaterCustomize.
-			mAnimationCameraStartGlobal -= LLVector3d(LLViewerCamera::getInstance()->getLeftAxis() * calcCustomizeAvatarUIOffset( mAnimationCameraStartGlobal ));
-		}
-	}
-	
-	//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, (getPosAgentFromGlobal(focus) - mFocusObject->getRenderPosition()) * ~mFocusObject->getRenderRotation());
-		}
-	}
-	else
-	{
-		setLookAt(LOOKAT_TARGET_FOCUS, NULL, 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 LLAgent::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 LLAgent::setFocusOnAvatar(BOOL focus_on_avatar, BOOL animate)
-{
-	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)
-	{
-		setFocusGlobal(LLVector3d::zero);
-		mCameraFOVZoomFactor = 0.f;
-		if (mCameraMode == CAMERA_MODE_THIRD_PERSON)
-		{
-			LLVector3 at_axis;
-			if (mAvatarObject.notNull() && mAvatarObject->getParent())
-			{
-				LLQuaternion obj_rot = ((LLViewerObject*)mAvatarObject->getParent())->getRenderRotation();
-				at_axis = LLViewerCamera::getInstance()->getAtAxis();
-				at_axis.mV[VZ] = 0.f;
-				at_axis.normalize();
-				resetAxes(at_axis * ~obj_rot);
-			}
-			else
-			{
-				at_axis = LLViewerCamera::getInstance()->getAtAxis();
-				at_axis.mV[VZ] = 0.f;
-				at_axis.normalize();
-				resetAxes(at_axis);
-			}
-		}
-	}
-	// unlocking camera from avatar
-	else if (mFocusOnAvatar && !focus_on_avatar)
-	{
-		// keep camera focus point consistent, even though it is now unlocked
-		setFocusGlobal(getPositionGlobal() + calcThirdPersonFocusOffset(), gAgent.getID());
-	}
-	
-	mFocusOnAvatar = focus_on_avatar;
-}
-*/
-
 //-----------------------------------------------------------------------------
 // heardChat()
 //-----------------------------------------------------------------------------
@@ -4600,7 +2021,7 @@ void LLAgent::heardChat(const LLUUID& id)
 	if (ll_rand(2) == 0) 
 	{
 		LLViewerObject *chatter = gObjectList.findObject(mLastChatterID);
-		gAgentCameraHACK.setLookAt(LOOKAT_TARGET_AUTO_LISTEN, chatter, LLVector3::zero);
+		gAgentCamera.setLookAt(LOOKAT_TARGET_AUTO_LISTEN, chatter, LLVector3::zero);
 	}			
 
 	mLastChatterID = id;
@@ -4613,7 +2034,7 @@ void LLAgent::heardChat(const LLUUID& id)
 void LLAgent::lookAtLastChat()
 {
 	// Block if camera is animating or not in normal third person camera mode
-	if (gAgentCameraHACK.mCameraAnimating || !gAgentCameraHACK.cameraThirdPerson())
+	if (gAgentCamera.mCameraAnimating || !gAgentCamera.cameraThirdPerson())
 	{
 		return;
 	}
@@ -4637,7 +2058,7 @@ void LLAgent::lookAtLastChat()
 
 			setControlFlags(AGENT_CONTROL_STOP);
 
-			gAgentCameraHACK.changeCameraToThirdPerson();
+			gAgentCamera.changeCameraToThirdPerson();
 
 			LLVector3 new_camera_pos = mAvatarObject->mHeadp->getWorldPosition();
 			LLVector3 left = delta_pos % LLVector3::z_axis;
@@ -4649,15 +2070,15 @@ void LLAgent::lookAtLastChat()
 			new_camera_pos += up * 0.2f;
 			if (chatter_av->mHeadp)
 			{
-				gAgentCameraHACK.setFocusGlobal(getPosGlobalFromAgent(chatter_av->mHeadp->getWorldPosition()), mLastChatterID);
-				gAgentCameraHACK.mCameraFocusOffsetTarget = getPosGlobalFromAgent(new_camera_pos) - gAgent.getPosGlobalFromAgent(chatter_av->mHeadp->getWorldPosition());
+				gAgentCamera.setFocusGlobal(getPosGlobalFromAgent(chatter_av->mHeadp->getWorldPosition()), mLastChatterID);
+				gAgentCamera.mCameraFocusOffsetTarget = getPosGlobalFromAgent(new_camera_pos) - gAgent.getPosGlobalFromAgent(chatter_av->mHeadp->getWorldPosition());
 			}
 			else
 			{
-				gAgentCameraHACK.setFocusGlobal(chatter->getPositionGlobal(), mLastChatterID);
-				gAgentCameraHACK.mCameraFocusOffsetTarget = getPosGlobalFromAgent(new_camera_pos) - chatter->getPositionGlobal();
+				gAgentCamera.setFocusGlobal(chatter->getPositionGlobal(), mLastChatterID);
+				gAgentCamera.mCameraFocusOffsetTarget = getPosGlobalFromAgent(new_camera_pos) - chatter->getPositionGlobal();
 			}
-			gAgentCameraHACK.setFocusOnAvatar(FALSE, TRUE);
+			gAgentCamera.setFocusOnAvatar(FALSE, TRUE);
 		}
 		else
 		{
@@ -4666,7 +2087,7 @@ void LLAgent::lookAtLastChat()
 
 			setControlFlags(AGENT_CONTROL_STOP);
 
-			gAgentCameraHACK.changeCameraToThirdPerson();
+			gAgentCamera.changeCameraToThirdPerson();
 
 			LLVector3 new_camera_pos = mAvatarObject->mHeadp->getWorldPosition();
 			LLVector3 left = delta_pos % LLVector3::z_axis;
@@ -4677,9 +2098,9 @@ void LLAgent::lookAtLastChat()
 			new_camera_pos += left * 0.3f;
 			new_camera_pos += up * 0.2f;
 
-			gAgentCameraHACK.setFocusGlobal(chatter->getPositionGlobal(), mLastChatterID);
-			gAgentCameraHACK.mCameraFocusOffsetTarget = getPosGlobalFromAgent(new_camera_pos) - chatter->getPositionGlobal();
-			gAgentCameraHACK.setFocusOnAvatar(FALSE, TRUE);
+			gAgentCamera.setFocusGlobal(chatter->getPositionGlobal(), mLastChatterID);
+			gAgentCamera.mCameraFocusOffsetTarget = getPosGlobalFromAgent(new_camera_pos) - chatter->getPositionGlobal();
+			gAgentCamera.setFocusOnAvatar(FALSE, TRUE);
 		}
 	}
 }
@@ -5190,7 +2611,7 @@ LLQuaternion LLAgent::getHeadRotation()
 		return LLQuaternion::DEFAULT;
 	}
 
-	if (!gAgentCameraHACK.cameraMouselook())
+	if (!gAgentCamera.cameraMouselook())
 	{
 		return mAvatarObject->getRotation();
 	}
@@ -5361,7 +2782,7 @@ void LLAgent::initOriginGlobal(const LLVector3d &origin_global)
 
 BOOL LLAgent::leftButtonGrabbed() const	
 { 
-	const BOOL camera_mouse_look = gAgentCameraHACK.cameraMouselook();
+	const BOOL camera_mouse_look = gAgentCamera.cameraMouselook();
 	return (!camera_mouse_look && mControlsTakenCount[CONTROL_LBUTTON_DOWN_INDEX] > 0) 
 		|| (camera_mouse_look && mControlsTakenCount[CONTROL_ML_LBUTTON_DOWN_INDEX] > 0)
 		|| (!camera_mouse_look && mControlsTakenPassedOnCount[CONTROL_LBUTTON_DOWN_INDEX] > 0)
@@ -5833,7 +3254,7 @@ void LLAgent::processAgentCachedTextureResponse(LLMessageSystem *mesgsys, void *
 		return;
 	}
 
-	if (gAgentCameraHACK.cameraCustomizeAvatar())
+	if (gAgentCamera.cameraCustomizeAvatar())
 	{
 		// ignore baked textures when in customize mode
 		return;
@@ -5990,7 +3411,7 @@ bool LLAgent::teleportCore(bool is_local)
 
 	// Close all pie menus, deselect land, etc.
 	// Don't change the camera until we know teleport succeeded. JC
-	gAgentCameraHACK.resetView(FALSE);
+	gAgentCamera.resetView(FALSE);
 
 	// local logic
 	LLViewerStats::getInstance()->incStat(LLViewerStats::ST_TELEPORT_COUNT);
@@ -6291,7 +3712,7 @@ void LLAgent::sendAgentSetAppearance()
 {
 	if (mAvatarObject.isNull()) return;
 
-	if (gAgentQueryManager.mNumPendingQueries > 0 && !gAgentCameraHACK.cameraCustomizeAvatar()) 
+	if (gAgentQueryManager.mNumPendingQueries > 0 && !gAgentCamera.cameraCustomizeAvatar()) 
 	{
 		return;
 	}
@@ -6540,9 +3961,7 @@ void LLAgent::renderAutoPilotTarget()
 	}
 }
 
-/********************************************************************************
- *
- */
+/********************************************************************************/
 
 LLAgentQueryManager gAgentQueryManager;
 
diff --git a/indra/newview/llagent.h b/indra/newview/llagent.h
index d196c1c1c1..1b378ef7b2 100644
--- a/indra/newview/llagent.h
+++ b/indra/newview/llagent.h
@@ -66,32 +66,6 @@ class LLAgentDropGroupViewerNode;
 //--------------------------------------------------------------------
 // Types
 //--------------------------------------------------------------------
-//--------------------------------------------------------------------
-// Types
-//--------------------------------------------------------------------
-
-/*
-enum ECameraMode
-{
-	CAMERA_MODE_THIRD_PERSON,
-	CAMERA_MODE_MOUSELOOK,
-	CAMERA_MODE_CUSTOMIZE_AVATAR,
-	CAMERA_MODE_FOLLOW
-};
-
-// Camera Presets for CAMERA_MODE_THIRD_PERSON
-enum ECameraPreset 
-{
-	// Default preset, what the Third Person Mode actually was
-	CAMERA_PRESET_REAR_VIEW,
-	
-	// "Looking at the Avatar from the front"
-	CAMERA_PRESET_FRONT_VIEW, 
-
-	// "Above and to the left, over the shoulder, pulled back a little on the zoom"
-	CAMERA_PRESET_GROUP_VIEW
-};
-*/
 
 enum EAnimRequest
 {
@@ -146,11 +120,12 @@ public:
 	void			setFirstLogin(BOOL b) 	{ mFirstLogin = b; }
 	// Return TRUE if the database reported this login as the first for this particular user.
 	BOOL 			isFirstLogin() const 	{ return mFirstLogin; }
+	BOOL 			isInitialized() const 	{ return mInitialized; }
 public:
-	BOOL			mInitialized;
-	BOOL			mFirstLogin;
 	std::string		mMOTD; 					// Message of the day
 private:
+	BOOL			mInitialized;
+	BOOL			mFirstLogin;
 	boost::shared_ptr<LLAgentListener> mListener;
 
 	//--------------------------------------------------------------------
@@ -455,8 +430,6 @@ public:
 	void			sendAnimationRequest(const LLUUID &anim_id, EAnimRequest request);
 	void			endAnimationUpdateUI();
 private:
-	LLFrameTimer	mAnimationTimer; 	// Seconds that transition animation has been active // SERAPH REMOVE
-	F32				mAnimationDuration;	// In seconds // SERAPH REMOVE
 	BOOL            mCustomAnim; 		// Current animation is ANIM_AGENT_CUSTOMIZE ?
 	LLAnimPauseRequest mPauseRequest;
 	BOOL			mViewsPushed; 		// Keep track of whether or not we have pushed views
@@ -498,44 +471,6 @@ public:
 	void			moveYaw(F32 mag, bool reset_view = true);
 	void			movePitch(F32 mag);
 
-	// SERAPH Remove this whole section
-	//--------------------------------------------------------------------
-	// Orbit
-	//--------------------------------------------------------------------
-public:
-	void			setOrbitLeftKey(F32 mag)	{ mOrbitLeftKey = mag; }
-	void			setOrbitRightKey(F32 mag)	{ mOrbitRightKey = mag; }
-	void			setOrbitUpKey(F32 mag)		{ mOrbitUpKey = mag; }
-	void			setOrbitDownKey(F32 mag)	{ mOrbitDownKey = mag; }
-	void			setOrbitInKey(F32 mag)		{ mOrbitInKey = mag; }
-	void			setOrbitOutKey(F32 mag)		{ mOrbitOutKey = mag; }
-private:
-	F32				mOrbitLeftKey;
-	F32				mOrbitRightKey;
-	F32				mOrbitUpKey;
-	F32				mOrbitDownKey;
-	F32				mOrbitInKey;
-	F32				mOrbitOutKey;
-	
-	// SERAPH Remove this whole section
-	//--------------------------------------------------------------------
-	// Pan
-	//--------------------------------------------------------------------
-public:
-	void			setPanLeftKey(F32 mag)		{ mPanLeftKey = mag; }
-	void			setPanRightKey(F32 mag)		{ mPanRightKey = mag; }
-	void			setPanUpKey(F32 mag)		{ mPanUpKey = mag; }
-	void			setPanDownKey(F32 mag)		{ mPanDownKey = mag; }
-	void			setPanInKey(F32 mag)		{ mPanInKey = mag; }
-	void			setPanOutKey(F32 mag)		{ mPanOutKey = mag; }
-private:
-	F32				mPanUpKey;						
-	F32				mPanDownKey;					
-	F32				mPanLeftKey;					
-	F32				mPanRightKey;					
-	F32				mPanInKey;
-	F32				mPanOutKey;	
-
 	//--------------------------------------------------------------------
  	// Move the avatar's frame
 	//--------------------------------------------------------------------
@@ -649,220 +584,6 @@ private:
 
 /********************************************************************************
  **                                                                            **
- **                    CAMERA
- **/
-
-/*
-	//--------------------------------------------------------------------
-	// Mode
-	//--------------------------------------------------------------------
-public:
-	void			changeCameraToDefault();
-	void			changeCameraToMouselook(BOOL animate = TRUE);
-	void			changeCameraToThirdPerson(BOOL animate = TRUE);
-	void			changeCameraToCustomizeAvatar(BOOL avatar_animate = TRUE, BOOL camera_animate = TRUE); // Trigger transition animation
-	void			changeCameraToFollow(BOOL animate = TRUE); 	// Ventrella
-	BOOL			cameraThirdPerson() const		{ return (mCameraMode == CAMERA_MODE_THIRD_PERSON && mLastCameraMode == CAMERA_MODE_THIRD_PERSON); }
-	BOOL			cameraMouselook() const			{ return (mCameraMode == CAMERA_MODE_MOUSELOOK && mLastCameraMode == CAMERA_MODE_MOUSELOOK); }
-	BOOL			cameraCustomizeAvatar() const	{ return (mCameraMode == CAMERA_MODE_CUSTOMIZE_AVATAR); }
-	BOOL			cameraFollow() const			{ return (mCameraMode == CAMERA_MODE_FOLLOW && mLastCameraMode == CAMERA_MODE_FOLLOW); }
-	ECameraMode		getCameraMode() const 			{ return mCameraMode; }
-	void			updateCamera();					// Call once per frame to update camera location/orientation
-	void			resetCamera(); 					// Slam camera into its default position
-private:
-	ECameraMode		mCameraMode;					// Target mode after transition animation is done
-	ECameraMode		mLastCameraMode;
-
-	//--------------------------------------------------------------------
-	// Preset
-	//--------------------------------------------------------------------
-public:
-	void switchCameraPreset(ECameraPreset preset);
-
-private:
-	
-	// Determines default camera offset depending on the current camera preset
-	LLVector3 getCameraOffsetInitial();
-
-	// Camera preset in Third Person Mode
-	ECameraPreset mCameraPreset; 
-
-	// Initial camera offsets
-	std::map<ECameraPreset, LLVector3> mCameraOffsetInitial;
-
-	// Initial focus offsets
-	std::map<ECameraPreset, LLVector3d> mFocusOffsetInitial;
-
-	//--------------------------------------------------------------------
-	// Position
-	//--------------------------------------------------------------------
-public:
-	LLVector3d		getCameraPositionGlobal() const;
-	const LLVector3 &getCameraPositionAgent() const;
-	LLVector3d		calcCameraPositionTargetGlobal(BOOL *hit_limit = NULL); // Calculate the camera position target
-	F32				getCameraMinOffGround(); 		// Minimum height off ground for this mode, meters
-	void			setCameraCollidePlane(const LLVector4 &plane) { mCameraCollidePlane = plane; }
-	BOOL			calcCameraMinDistance(F32 &obj_min_distance);
-	F32				calcCustomizeAvatarUIOffset(const LLVector3d& camera_pos_global);
-	F32				getCurrentCameraBuildOffset() 	{ return (F32)mCameraFocusOffset.length(); }
-private:
-	F32				mCurrentCameraDistance;	 		// Current camera offset from avatar
-	F32				mTargetCameraDistance;			// Target camera offset from avatar
-	F32				mCameraFOVZoomFactor;			// Amount of fov zoom applied to camera when zeroing in on an object
-	F32				mCameraCurrentFOVZoomFactor;	// Interpolated fov zoom
-	F32				mCameraFOVDefault;				// Default field of view that is basis for FOV zoom effect
-	LLVector4		mCameraCollidePlane;			// Colliding plane for camera
-	F32				mCameraZoomFraction;			// Mousewheel driven fraction of zoom
-	LLVector3		mCameraPositionAgent;			// Camera position in agent coordinates
-	LLVector3		mCameraVirtualPositionAgent;	// Camera virtual position (target) before performing FOV zoom
-	LLVector3d      mCameraSmoothingLastPositionGlobal;    
-	LLVector3d      mCameraSmoothingLastPositionAgent;
-	BOOL            mCameraSmoothingStop;
-	LLVector3		mCameraLag;						// Third person camera lag
-	LLVector3		mCameraUpVector;				// Camera's up direction in world coordinates (determines the 'roll' of the view)
-
-	//--------------------------------------------------------------------
-	// Follow
-	//--------------------------------------------------------------------
-public:
-	void			setUsingFollowCam(bool using_follow_cam);
-private:
-	LLFollowCam 	mFollowCam; 			// Ventrella
-
-	//--------------------------------------------------------------------
-	// Sit
-	//--------------------------------------------------------------------
-public:
-	void			setupSitCamera();
-	BOOL			sitCameraEnabled() 		{ return mSitCameraEnabled; }
-	void			setSitCamera(const LLUUID &object_id, 
-								 const LLVector3 &camera_pos = LLVector3::zero, const LLVector3 &camera_focus = LLVector3::zero);
-private:
-	LLPointer<LLViewerObject> mSitCameraReferenceObject; // Object to which camera is related when sitting
-	BOOL			mSitCameraEnabled;		// Use provided camera information when sitting?
-	LLVector3		mSitCameraPos;			// Root relative camera pos when sitting
-	LLVector3		mSitCameraFocus;		// Root relative camera target when sitting
-#endif
-
-	//--------------------------------------------------------------------
-	// Animation
-	//--------------------------------------------------------------------
-public:
-	void			setCameraAnimating(BOOL b)			{ mCameraAnimating = b; }
-	BOOL			getCameraAnimating()				{ return mCameraAnimating; }
-	void			setAnimationDuration(F32 seconds) 	{ mAnimationDuration = seconds; }
-	void			startCameraAnimation();
-	void			stopCameraAnimation();
-private:
-	BOOL			mCameraAnimating;					// Camera is transitioning from one mode to another
-	LLVector3d		mAnimationCameraStartGlobal;		// Camera start position, global coords
-	LLVector3d		mAnimationFocusStartGlobal;			// Camera focus point, global coords
-
-	//--------------------------------------------------------------------
-	// Focus
-	//--------------------------------------------------------------------
-public:
-	LLVector3d		calcFocusPositionTargetGlobal();
-	LLVector3		calcFocusOffset(LLViewerObject *object, LLVector3 pos_agent, S32 x, S32 y);
-	BOOL			getFocusOnAvatar() const		{ return mFocusOnAvatar; }
-	LLPointer<LLViewerObject>&	getFocusObject() 	{ return mFocusObject; }
-	F32				getFocusObjectDist() const		{ return mFocusObjectDist; }
-	void			updateFocusOffset();
-	void			validateFocusObject();
-	void			setFocusGlobal(const LLPickInfo& pick);
-	void			setFocusGlobal(const LLVector3d &focus, const LLUUID &object_id = LLUUID::null);
-	void			setFocusOnAvatar(BOOL focus, BOOL animate);
-	void			setCameraPosAndFocusGlobal(const LLVector3d& pos, const LLVector3d& focus, const LLUUID &object_id);
-	void			clearFocusObject();
-	void			setFocusObject(LLViewerObject* object);
-	void			setObjectTracking(BOOL track) 	{ mTrackFocusObject = track; }
-	const LLVector3d &getFocusGlobal() const		{ return mFocusGlobal; }
-	const LLVector3d &getFocusTargetGlobal() const	{ return mFocusTargetGlobal; }
-private:
-	LLVector3d		mCameraFocusOffset;				// Offset from focus point in build mode
-	LLVector3d		mCameraFocusOffsetTarget;		// Target towards which we are lerping the camera's focus offset
-	BOOL			mFocusOnAvatar;					
-	LLVector3d		mFocusGlobal;
-	LLVector3d		mFocusTargetGlobal;
-	LLPointer<LLViewerObject> mFocusObject;
-	F32				mFocusObjectDist;
-	LLVector3		mFocusObjectOffset;
-	F32				mFocusDotRadius; 				// Meters
-	BOOL			mTrackFocusObject;
-	F32				mUIOffset;	
-	
-	//--------------------------------------------------------------------
-	// Third person
-	//--------------------------------------------------------------------
-public:
-	LLVector3d		calcThirdPersonFocusOffset();
-	void			setThirdPersonHeadOffset(LLVector3 offset) 	{ mThirdPersonHeadOffset = offset; }	
-private:
-	LLVector3		mThirdPersonHeadOffset;						// Head offset for third person camera position
-
-	//--------------------------------------------------------------------
-	// Orbit
-	//--------------------------------------------------------------------
-public:
-	void			cameraOrbitAround(const F32 radians);	// Rotate camera CCW radians about build focus point
-	void			cameraOrbitOver(const F32 radians);		// Rotate camera forward radians over build focus point
-	void			cameraOrbitIn(const F32 meters);		// Move camera in toward build focus point
-
-	//--------------------------------------------------------------------
-	// Zoom
-	//--------------------------------------------------------------------
-public:
-	void			handleScrollWheel(S32 clicks); 			// Mousewheel driven zoom
-	void			cameraZoomIn(const F32 factor);			// Zoom in by fraction of current distance
-	F32				getCameraZoomFraction();				// Get camera zoom as fraction of minimum and maximum zoom
-	void			setCameraZoomFraction(F32 fraction);	// Set camera zoom as fraction of minimum and maximum zoom
-	F32				calcCameraFOVZoomFactor();
-
-	//--------------------------------------------------------------------
-	// Pan
-	//--------------------------------------------------------------------
-public:
-	void			cameraPanIn(const F32 meters);
-	void			cameraPanLeft(const F32 meters);
-	void			cameraPanUp(const F32 meters);
-	
-	//--------------------------------------------------------------------
-	// View
-	//--------------------------------------------------------------------
-public:
-	// Called whenever the agent moves.  Puts camera back in default position, deselects items, etc.
-	void			resetView(BOOL reset_camera = TRUE, BOOL change_camera = FALSE);
-	// Called on camera movement.  Unlocks camera from the default position behind the avatar.
-	void			unlockView();
-
-	//--------------------------------------------------------------------
-	// Mouselook
-	//--------------------------------------------------------------------
-public:
-	BOOL			getForceMouselook() const 			{ return mForceMouselook; }
-	void			setForceMouselook(BOOL mouselook) 	{ mForceMouselook = mouselook; }
-private:
-	BOOL			mForceMouselook;
-	
-*/
-
-	//--------------------------------------------------------------------
-	// HUD
-	//--------------------------------------------------------------------
-public:
-	const LLColor4	&getEffectColor();
-	void			setEffectColor(const LLColor4 &color);
-private:
-	LLUIColor 		mEffectColor;
-
-/**                    Camera
- **                                                                            **
- *******************************************************************************/
-
-
-
-/********************************************************************************
- **                                                                            **
  **                    ACCESS
  **/
 
@@ -935,8 +656,6 @@ public:
 	LLQuaternion	getHeadRotation();
 	BOOL			needsRenderAvatar(); // TRUE when camera mode is such that your own avatar should draw
 	BOOL			needsRenderHead();
-public:
-	F32				mDrawDistance; // SERAPH REMOVE
 private:
 	BOOL			mShowAvatar; 		// Should we render the avatar?
 	U32				mAppearanceSerialNum;
@@ -951,6 +670,15 @@ public:
 private:
 	U8				mRenderState; // Current behavior state of agent
 
+	//--------------------------------------------------------------------
+	// HUD
+	//--------------------------------------------------------------------
+public:
+	const LLColor4	&getEffectColor();
+	void			setEffectColor(const LLColor4 &color);
+private:
+	LLUIColor 		mEffectColor;
+
 /**                    Rendering
  **                                                                            **
  *******************************************************************************/
diff --git a/indra/newview/llagentcamera.cpp b/indra/newview/llagentcamera.cpp
index f1422e2442..c51edbaf4b 100644
--- a/indra/newview/llagentcamera.cpp
+++ b/indra/newview/llagentcamera.cpp
@@ -80,47 +80,15 @@
 #include "llworld.h"
 #include "llworldmap.h"
 
-static LLAgent gAgentHACK = gAgent;
-
 using namespace LLVOAvatarDefines;
 
 extern LLMenuBarGL* gMenuBarView;
 
-/*
-const BOOL ANIMATE = TRUE;
-const U8 AGENT_STATE_TYPING =	0x04;
-const U8 AGENT_STATE_EDITING =  0x10;
-
-//drone wandering constants
-const F32 MAX_WANDER_TIME = 20.f;						// seconds
-const F32 MAX_HEADING_HALF_ERROR = 0.2f;				// radians
-const F32 WANDER_MAX_SLEW_RATE = 2.f * DEG_TO_RAD;		// radians / frame
-const F32 WANDER_TARGET_MIN_DISTANCE = 10.f;			// meters
-
-// Autopilot constants
-const F32 AUTOPILOT_HEADING_HALF_ERROR = 10.f * DEG_TO_RAD;	// radians
-const F32 AUTOPILOT_MAX_SLEW_RATE = 1.f * DEG_TO_RAD;		// radians / frame
-const F32 AUTOPILOT_STOP_DISTANCE = 2.f;					// meters
-const F32 AUTOPILOT_HEIGHT_ADJUST_DISTANCE = 8.f;			// meters
-const F32 AUTOPILOT_MIN_TARGET_HEIGHT_OFF_GROUND = 1.f;	// meters
-const F32 AUTOPILOT_MAX_TIME_NO_PROGRESS = 1.5f;		// seconds
-
-// face editing constants
-const LLVector3d FACE_EDIT_CAMERA_OFFSET(0.4f, -0.05f, 0.07f);
-const LLVector3d FACE_EDIT_TARGET_OFFSET(0.f, 0.f, 0.05f);
-*/
-
 // 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 METERS_PER_WHEEL_CLICK = 1.f;
-
-const F32 MAX_TIME_DELTA = 1.f;
-*/
-
 const F32 CAMERA_ZOOM_HALF_LIFE = 0.07f;	// seconds
 const F32 FOV_ZOOM_HALF_LIFE = 0.07f;	// seconds
 
@@ -152,28 +120,10 @@ const F32 OBJECT_MIN_ZOOM = 0.02f;
 const F32 APPEARANCE_MIN_ZOOM = 0.39f;
 const F32 APPEARANCE_MAX_ZOOM = 8.f;
 
-/*
-// fidget constants
-const F32 MIN_FIDGET_TIME = 8.f; // seconds
-const F32 MAX_FIDGET_TIME = 20.f; // seconds
-
-const S32 MAX_NUM_CHAT_POSITIONS = 10;
-*/
-
 const F32 GROUND_TO_AIR_CAMERA_TRANSITION_TIME = 0.5f;
 const F32 GROUND_TO_AIR_CAMERA_TRANSITION_START_TIME = 0.5f;
-/*
-const F32 MAX_VELOCITY_AUTO_LAND_SQUARED = 4.f * 4.f;
-
-const F32 MAX_FOCUS_OFFSET = 20.f;
-*/
 
 const F32 OBJECT_EXTENTS_PADDING = 0.5f;
-/*
-const F32 MIN_RADIUS_ALPHA_SIZZLE = 0.5f;
-
-const F64 CHAT_AGE_FAST_RATE = 3.0;
-*/
 
 // The agent instance.
 LLAgentCamera gAgentCamera;
@@ -182,9 +132,16 @@ LLAgentCamera gAgentCamera;
 // LLAgentCamera()
 //-----------------------------------------------------------------------------
 LLAgentCamera::LLAgentCamera() :
+	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 ),
 
@@ -238,6 +195,7 @@ LLAgentCamera::LLAgentCamera() :
 	mPanInKey(0.f),
 	mPanOutKey(0.f)
 {
+	mFollowCam.setMaxCameraDistantFromSubject( MAX_CAMERA_DISTANCE_FROM_AGENT );
 }
 
 // Requires gSavedSettings to be initialized.
@@ -248,6 +206,8 @@ 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);
@@ -313,9 +273,9 @@ LLAgentCamera::~LLAgentCamera()
 //-----------------------------------------------------------------------------
 void LLAgentCamera::resetView(BOOL reset_camera, BOOL change_camera)
 {
-	if (gAgentHACK.mAutoPilot)
+	if (gAgent.mAutoPilot)
 	{
-		gAgentHACK.stopAutoPilot(TRUE);
+		gAgent.stopAutoPilot(TRUE);
 	}
 
 	if (!gNoRender)
@@ -369,10 +329,10 @@ void LLAgentCamera::resetView(BOOL reset_camera, BOOL change_camera)
 		if (!gViewerWindow->getLeftMouseDown() && cameraThirdPerson())
 		{
 			// leaving mouse-steer mode
-			LLVector3 agent_at_axis = gAgentHACK.getAtAxis();
-			agent_at_axis -= projected_vec(agent_at_axis, gAgentHACK.getReferenceUpVector());
+			LLVector3 agent_at_axis = gAgent.getAtAxis();
+			agent_at_axis -= projected_vec(agent_at_axis, gAgent.getReferenceUpVector());
 			agent_at_axis.normalize();
-			gAgentHACK.resetAxes(lerp(gAgentHACK.getAtAxis(), agent_at_axis, LLCriticalDamp::getInterpolant(0.3f)));
+			gAgent.resetAxes(lerp(gAgent.getAtAxis(), agent_at_axis, LLCriticalDamp::getInterpolant(0.3f)));
 		}
 
 		setFocusOnAvatar(TRUE, ANIMATE);
@@ -391,9 +351,9 @@ void LLAgentCamera::unlockView()
 {
 	if (getFocusOnAvatar())
 	{
-		if (gAgentHACK.mAvatarObject.notNull())
+		if (gAgent.mAvatarObject.notNull())
 		{
-			setFocusGlobal( LLVector3d::zero, gAgentHACK.mAvatarObject->mID );
+			setFocusGlobal( LLVector3d::zero, gAgent.mAvatarObject->mID );
 		}
 		setFocusOnAvatar(FALSE, FALSE);	// no animation
 	}
@@ -407,7 +367,7 @@ void LLAgentCamera::slamLookAt(const LLVector3 &look_at)
 	LLVector3 look_at_norm = look_at;
 	look_at_norm.mV[VZ] = 0.f;
 	look_at_norm.normalize();
-	gAgentHACK.resetAxes(look_at_norm);
+	gAgent.resetAxes(look_at_norm);
 }
 
 //-----------------------------------------------------------------------------
@@ -607,7 +567,7 @@ BOOL LLAgentCamera::calcCameraMinDistance(F32 &obj_min_distance)
 	
 	LLQuaternion inv_object_rot = ~mFocusObject->getRenderRotation();
 	LLVector3 target_offset_origin = mFocusObjectOffset;
-	LLVector3 camera_offset_target(getCameraPositionAgent() - gAgentHACK.getPosAgentFromGlobal(mFocusTargetGlobal));
+	LLVector3 camera_offset_target(getCameraPositionAgent() - gAgent.getPosAgentFromGlobal(mFocusTargetGlobal));
 
 	// convert offsets into object local space
 	camera_offset_target.rotVec(inv_object_rot);
@@ -870,7 +830,7 @@ void LLAgentCamera::cameraOrbitAround(const F32 radians)
 	}
 	else if (mFocusOnAvatar && (mCameraMode == CAMERA_MODE_THIRD_PERSON || mCameraMode == CAMERA_MODE_FOLLOW))
 	{
-		gAgentHACK.mFrameAgent.rotate(radians, gAgentHACK.getReferenceUpVector());
+		gAgent.mFrameAgent.rotate(radians, gAgent.getReferenceUpVector());
 	}
 	else
 	{
@@ -893,14 +853,14 @@ void LLAgentCamera::cameraOrbitOver(const F32 angle)
 	}
 	else if (mFocusOnAvatar && mCameraMode == CAMERA_MODE_THIRD_PERSON)
 	{
-		gAgentHACK.pitch(angle);
+		gAgent.pitch(angle);
 	}
 	else
 	{
 		LLVector3 camera_offset_unit(mCameraFocusOffsetTarget);
 		camera_offset_unit.normalize();
 
-		F32 angle_from_up = acos( camera_offset_unit * gAgentHACK.getReferenceUpVector() );
+		F32 angle_from_up = acos( camera_offset_unit * gAgent.getReferenceUpVector() );
 
 		LLVector3d left_axis;
 		left_axis.setVec(LLViewerCamera::getInstance()->getLeftAxis());
@@ -1111,28 +1071,28 @@ void LLAgentCamera::updateLookAt(const S32 mouse_x, const S32 mouse_y)
 	static LLVector3 last_at_axis;
 
 
-	if (gAgentHACK.mAvatarObject.isNull())
+	if (gAgent.mAvatarObject.isNull())
 	{
 		return;
 	}
 
-	LLQuaternion av_inv_rot = ~gAgentHACK.mAvatarObject->mRoot.getWorldRotation();
-	LLVector3 root_at = LLVector3::x_axis * gAgentHACK.mAvatarObject->mRoot.getWorldRotation();
+	LLQuaternion av_inv_rot = ~gAgent.mAvatarObject->mRoot.getWorldRotation();
+	LLVector3 root_at = LLVector3::x_axis * gAgent.mAvatarObject->mRoot.getWorldRotation();
 
 	if 	((gViewerWindow->getMouseVelocityStat()->getCurrent() < 0.01f) &&
 		(root_at * last_at_axis > 0.95f ))
 	{
-		LLVector3 vel = gAgentHACK.mAvatarObject->getVelocity();
+		LLVector3 vel = gAgent.mAvatarObject->getVelocity();
 		if (vel.magVecSquared() > 4.f)
 		{
-			setLookAt(LOOKAT_TARGET_IDLE, gAgentHACK.mAvatarObject, vel * av_inv_rot);
+			setLookAt(LOOKAT_TARGET_IDLE, gAgent.mAvatarObject, vel * av_inv_rot);
 		}
 		else
 		{
 			// *FIX: rotate mframeagent by sit object's rotation?
-			LLQuaternion look_rotation = gAgentHACK.mAvatarObject->isSitting() ? gAgentHACK.mAvatarObject->getRenderRotation() : gAgentHACK.mFrameAgent.getQuaternion(); // use camera's current rotation
+			LLQuaternion look_rotation = gAgent.mAvatarObject->isSitting() ? gAgent.mAvatarObject->getRenderRotation() : gAgent.mFrameAgent.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, gAgentHACK.mAvatarObject, look_offset);
+			setLookAt(LOOKAT_TARGET_IDLE, gAgent.mAvatarObject, look_offset);
 		}
 		last_at_axis = root_at;
 		return;
@@ -1142,7 +1102,7 @@ void LLAgentCamera::updateLookAt(const S32 mouse_x, const S32 mouse_y)
 	
 	if (CAMERA_MODE_CUSTOMIZE_AVATAR == getCameraMode())
 	{
-		setLookAt(LOOKAT_TARGET_NONE, gAgentHACK.mAvatarObject, LLVector3(-2.f, 0.f, 0.f));	
+		setLookAt(LOOKAT_TARGET_NONE, gAgent.mAvatarObject, LLVector3(-2.f, 0.f, 0.f));	
 	}
 	else
 	{
@@ -1171,7 +1131,7 @@ void LLAgentCamera::updateLookAt(const S32 mouse_x, const S32 mouse_y)
 		headLookAxis = frameCamera.getAtAxis();
 		// RN: we use world-space offset for mouselook and freelook
 		//headLookAxis = headLookAxis * av_inv_rot;
-		setLookAt(lookAtType, gAgentHACK.mAvatarObject, headLookAxis);
+		setLookAt(lookAtType, gAgent.mAvatarObject, headLookAxis);
 	}
 }
 
@@ -1192,13 +1152,13 @@ void LLAgentCamera::updateCamera()
 
 	validateFocusObject();
 
-	if (gAgentHACK.mAvatarObject.notNull() && 
-		gAgentHACK.mAvatarObject->isSitting() &&
+	if (gAgent.mAvatarObject.notNull() && 
+		gAgent.mAvatarObject->isSitting() &&
 		camera_mode == CAMERA_MODE_MOUSELOOK)
 	{
 		//Ventrella
 		//changed camera_skyward to the new global "mCameraUpVector"
-		mCameraUpVector = mCameraUpVector * gAgentHACK.mAvatarObject->getRenderRotation();
+		mCameraUpVector = mCameraUpVector * gAgent.mAvatarObject->getRenderRotation();
 		//end Ventrella
 	}
 
@@ -1306,7 +1266,7 @@ void LLAgentCamera::updateCamera()
 	//Ventrella
 	if ( mCameraMode == CAMERA_MODE_FOLLOW )
 	{
-		if ( gAgentHACK.mAvatarObject.notNull() )
+		if ( gAgent.mAvatarObject.notNull() )
 		{
 			//--------------------------------------------------------------------------------
 			// this is where the avatar's position and rotation are given to followCam, and 
@@ -1314,13 +1274,13 @@ void LLAgentCamera::updateCamera()
 			// (2) focus, and (3) upvector. They can then be queried elsewhere in llAgent.
 			//--------------------------------------------------------------------------------
 			// *TODO: use combined rotation of frameagent and sit object
-			LLQuaternion avatarRotationForFollowCam = gAgentHACK.mAvatarObject->isSitting() ? gAgentHACK.mAvatarObject->getRenderRotation() : gAgentHACK.mFrameAgent.getQuaternion();
+			LLQuaternion avatarRotationForFollowCam = gAgent.mAvatarObject->isSitting() ? gAgent.mAvatarObject->getRenderRotation() : gAgent.mFrameAgent.getQuaternion();
 
 			LLFollowCamParams* current_cam = LLFollowCamMgr::getActiveFollowCamParams();
 			if (current_cam)
 			{
 				mFollowCam.copyParams(*current_cam);
-				mFollowCam.setSubjectPositionAndRotation( gAgentHACK.mAvatarObject->getRenderPosition(), avatarRotationForFollowCam );
+				mFollowCam.setSubjectPositionAndRotation( gAgent.mAvatarObject->getRenderPosition(), avatarRotationForFollowCam );
 				mFollowCam.update();
 				LLViewerJoystick::getInstance()->setCameraNeedsUpdate(true);
 			}
@@ -1335,14 +1295,14 @@ void LLAgentCamera::updateCamera()
 	BOOL hit_limit;
 	LLVector3d camera_pos_global;
 	LLVector3d camera_target_global = calcCameraPositionTargetGlobal(&hit_limit);
-	mCameraVirtualPositionAgent = gAgentHACK.getPosAgentFromGlobal(camera_target_global);
+	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);
 
-	gAgentHACK.mShowAvatar = TRUE; // can see avatar by default
+	gAgent.mShowAvatar = TRUE; // can see avatar by default
 
 	// Adjust position for animation
 	if (mCameraAnimating)
@@ -1375,7 +1335,7 @@ void LLAgentCamera::updateCamera()
 		{
 			if (fraction_of_animation < animation_start_fraction || fraction_of_animation > animation_finish_fraction )
 			{
-				gAgentHACK.mShowAvatar = FALSE;
+				gAgent.mShowAvatar = FALSE;
 			}
 
 			// ...adjust position for animation
@@ -1391,26 +1351,26 @@ void LLAgentCamera::updateCamera()
 			camera_pos_global = camera_target_global;
 			mFocusGlobal = focus_target_global;
 
-			gAgentHACK.endAnimationUpdateUI();
-			gAgentHACK.mShowAvatar = TRUE;
+			gAgent.endAnimationUpdateUI();
+			gAgent.mShowAvatar = TRUE;
 		}
 
-		if (gAgentHACK.getAvatarObject() && mCameraMode != CAMERA_MODE_MOUSELOOK)
+		if (gAgent.getAvatarObject() && mCameraMode != CAMERA_MODE_MOUSELOOK)
 		{
-			gAgentHACK.getAvatarObject()->updateAttachmentVisibility(mCameraMode);
+			gAgent.getAvatarObject()->updateAttachmentVisibility(mCameraMode);
 		}
 	}
 	else 
 	{
 		camera_pos_global = camera_target_global;
 		mFocusGlobal = focus_target_global;
-		gAgentHACK.mShowAvatar = TRUE;
+		gAgent.mShowAvatar = TRUE;
 	}
 
 	// smoothing
 	if (TRUE)
 	{
-		LLVector3d agent_pos = gAgentHACK.getPositionGlobal();
+		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
@@ -1461,9 +1421,9 @@ void LLAgentCamera::updateCamera()
 	}
 
 
-	LLVector3 focus_agent = gAgentHACK.getPosAgentFromGlobal(mFocusGlobal);
+	LLVector3 focus_agent = gAgent.getPosAgentFromGlobal(mFocusGlobal);
 	
-	mCameraPositionAgent = gAgentHACK.getPosAgentFromGlobal(camera_pos_global);
+	mCameraPositionAgent = gAgent.getPosAgentFromGlobal(camera_pos_global);
 
 	// Move the camera
 
@@ -1487,48 +1447,48 @@ void LLAgentCamera::updateCamera()
 	// 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 = gAgentHACK.getPositionGlobal(); 
-	if (! gAgentHACK.mLastPositionGlobal.isExactlyZero())
+	LLVector3d global_pos = gAgent.getPositionGlobal(); 
+	if (! gAgent.mLastPositionGlobal.isExactlyZero())
 	{
-		LLVector3d delta = global_pos - gAgentHACK.mLastPositionGlobal;
-		gAgentHACK.mDistanceTraveled += delta.magVec();
+		LLVector3d delta = global_pos - gAgent.mLastPositionGlobal;
+		gAgent.mDistanceTraveled += delta.magVec();
 	}
-	gAgentHACK.mLastPositionGlobal = global_pos;
+	gAgent.mLastPositionGlobal = global_pos;
 	
-	if (LLVOAvatar::sVisibleInFirstPerson && gAgentHACK.mAvatarObject.notNull() && !gAgentHACK.mAvatarObject->isSitting() && cameraMouselook())
+	if (LLVOAvatar::sVisibleInFirstPerson && gAgent.mAvatarObject.notNull() && !gAgent.mAvatarObject->isSitting() && cameraMouselook())
 	{
-		LLVector3 head_pos = gAgentHACK.mAvatarObject->mHeadp->getWorldPosition() + 
-			LLVector3(0.08f, 0.f, 0.05f) * gAgentHACK.mAvatarObject->mHeadp->getWorldRotation() + 
-			LLVector3(0.1f, 0.f, 0.f) * gAgentHACK.mAvatarObject->mPelvisp->getWorldRotation();
+		LLVector3 head_pos = gAgent.mAvatarObject->mHeadp->getWorldPosition() + 
+			LLVector3(0.08f, 0.f, 0.05f) * gAgent.mAvatarObject->mHeadp->getWorldRotation() + 
+			LLVector3(0.1f, 0.f, 0.f) * gAgent.mAvatarObject->mPelvisp->getWorldRotation();
 		LLVector3 diff = mCameraPositionAgent - head_pos;
-		diff = diff * ~gAgentHACK.mAvatarObject->mRoot.getWorldRotation();
+		diff = diff * ~gAgent.mAvatarObject->mRoot.getWorldRotation();
 
-		LLJoint* torso_joint = gAgentHACK.mAvatarObject->mTorsop;
-		LLJoint* chest_joint = gAgentHACK.mAvatarObject->mChestp;
+		LLJoint* torso_joint = gAgent.mAvatarObject->mTorsop;
+		LLJoint* chest_joint = gAgent.mAvatarObject->mChestp;
 		LLVector3 torso_scale = torso_joint->getScale();
 		LLVector3 chest_scale = chest_joint->getScale();
 
 		// shorten avatar skeleton to avoid foot interpenetration
-		if (!gAgentHACK.mAvatarObject->mInAir)
+		if (!gAgent.mAvatarObject->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 = gAgentHACK.mAvatarObject->mNeckp;
+			LLJoint* neck_joint = gAgent.mAvatarObject->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;
 		}
 
-		gAgentHACK.mAvatarObject->mPelvisp->setPosition(gAgentHACK.mAvatarObject->mPelvisp->getPosition() + diff);
+		gAgent.mAvatarObject->mPelvisp->setPosition(gAgent.mAvatarObject->mPelvisp->getPosition() + diff);
 
-		gAgentHACK.mAvatarObject->mRoot.updateWorldMatrixChildren();
+		gAgent.mAvatarObject->mRoot.updateWorldMatrixChildren();
 
-		for (LLVOAvatar::attachment_map_t::iterator iter = gAgentHACK.mAvatarObject->mAttachmentPoints.begin(); 
-			 iter != gAgentHACK.mAvatarObject->mAttachmentPoints.end(); )
+		for (LLVOAvatar::attachment_map_t::iterator iter = gAgent.mAvatarObject->mAttachmentPoints.begin(); 
+			 iter != gAgent.mAvatarObject->mAttachmentPoints.end(); )
 		{
 			LLVOAvatar::attachment_map_t::iterator curiter = iter++;
 			LLViewerJointAttachment* attachment = curiter->second;
@@ -1557,7 +1517,7 @@ void LLAgentCamera::updateFocusOffset()
 	validateFocusObject();
 	if (mFocusObject.notNull())
 	{
-		LLVector3d obj_pos = gAgentHACK.getPosGlobalFromAgent(mFocusObject->getRenderPosition());
+		LLVector3d obj_pos = gAgent.getPosGlobalFromAgent(mFocusObject->getRenderPosition());
 		mFocusObjectOffset.setVec(mFocusTargetGlobal - obj_pos);
 	}
 }
@@ -1624,13 +1584,13 @@ LLVector3d LLAgentCamera::calcFocusPositionTargetGlobal()
 	else if (mCameraMode == CAMERA_MODE_MOUSELOOK)
 	{
 		LLVector3d at_axis(1.0, 0.0, 0.0);
-		LLQuaternion agent_rot = gAgentHACK.mFrameAgent.getQuaternion();
-		if (gAgentHACK.mAvatarObject.notNull() && gAgentHACK.mAvatarObject->getParent())
+		LLQuaternion agent_rot = gAgent.mFrameAgent.getQuaternion();
+		if (gAgent.mAvatarObject.notNull() && gAgent.mAvatarObject->getParent())
 		{
-			LLViewerObject* root_object = (LLViewerObject*)gAgentHACK.mAvatarObject->getRoot();
+			LLViewerObject* root_object = (LLViewerObject*)gAgent.mAvatarObject->getRoot();
 			if (!root_object->flagCameraDecoupled())
 			{
-				agent_rot *= ((LLViewerObject*)(gAgentHACK.mAvatarObject->getParent()))->getRenderRotation();
+				agent_rot *= ((LLViewerObject*)(gAgent.mAvatarObject->getParent()))->getRenderRotation();
 			}
 		}
 		at_axis = at_axis * agent_rot;
@@ -1676,22 +1636,22 @@ LLVector3d LLAgentCamera::calcFocusPositionTargetGlobal()
 				updateFocusOffset();
 			}
 			LLVector3 focus_agent = mFocusObject->getRenderPosition() + mFocusObjectOffset;
-			mFocusTargetGlobal.setVec(gAgentHACK.getPosGlobalFromAgent(focus_agent));
+			mFocusTargetGlobal.setVec(gAgent.getPosGlobalFromAgent(focus_agent));
 		}
 		return mFocusTargetGlobal;
 	}
-	else if (mSitCameraEnabled && gAgentHACK.mAvatarObject.notNull() && gAgentHACK.mAvatarObject->isSitting() && mSitCameraReferenceObject.notNull())
+	else if (mSitCameraEnabled && gAgent.mAvatarObject.notNull() && gAgent.mAvatarObject->isSitting() && mSitCameraReferenceObject.notNull())
 	{
 		// sit camera
 		LLVector3 object_pos = mSitCameraReferenceObject->getRenderPosition();
 		LLQuaternion object_rot = mSitCameraReferenceObject->getRenderRotation();
 
 		LLVector3 target_pos = object_pos + (mSitCameraFocus * object_rot);
-		return gAgentHACK.getPosGlobalFromAgent(target_pos);
+		return gAgent.getPosGlobalFromAgent(target_pos);
 	}
 	else
 	{
-		return gAgentHACK.getPositionGlobal() + calcThirdPersonFocusOffset();
+		return gAgent.getPositionGlobal() + calcThirdPersonFocusOffset();
 	}
 }
 
@@ -1700,10 +1660,10 @@ LLVector3d LLAgentCamera::calcThirdPersonFocusOffset()
 	// ...offset from avatar
 	LLVector3d focus_offset;
 
-	LLQuaternion agent_rot = gAgentHACK.mFrameAgent.getQuaternion();
-	if (!gAgentHACK.mAvatarObject.isNull() && gAgentHACK.mAvatarObject->getParent())
+	LLQuaternion agent_rot = gAgent.mFrameAgent.getQuaternion();
+	if (!gAgent.mAvatarObject.isNull() && gAgent.mAvatarObject->getParent())
 	{
-		agent_rot *= ((LLViewerObject*)(gAgentHACK.mAvatarObject->getParent()))->getRenderRotation();
+		agent_rot *= ((LLViewerObject*)(gAgent.mAvatarObject->getParent()))->getRenderRotation();
 	}
 
 	focus_offset = mFocusOffsetInitial[mCameraPreset] * agent_rot;
@@ -1713,14 +1673,14 @@ LLVector3d LLAgentCamera::calcThirdPersonFocusOffset()
 void LLAgentCamera::setupSitCamera()
 {
 	// agent frame entering this function is in world coordinates
-	if (gAgentHACK.mAvatarObject.notNull() && gAgentHACK.mAvatarObject->getParent())
+	if (gAgent.mAvatarObject.notNull() && gAgent.mAvatarObject->getParent())
 	{
-		LLQuaternion parent_rot = ((LLViewerObject*)gAgentHACK.mAvatarObject->getParent())->getRenderRotation();
+		LLQuaternion parent_rot = ((LLViewerObject*)gAgent.mAvatarObject->getParent())->getRenderRotation();
 		// slam agent coordinate frame to proper parent local version
-		LLVector3 at_axis = gAgentHACK.mFrameAgent.getAtAxis();
+		LLVector3 at_axis = gAgent.mFrameAgent.getAtAxis();
 		at_axis.mV[VZ] = 0.f;
 		at_axis.normalize();
-		gAgentHACK.resetAxes(at_axis * ~parent_rot);
+		gAgent.resetAxes(at_axis * ~parent_rot);
 	}
 }
 
@@ -1737,7 +1697,7 @@ const LLVector3 &LLAgentCamera::getCameraPositionAgent() const
 //-----------------------------------------------------------------------------
 LLVector3d LLAgentCamera::getCameraPositionGlobal() const
 {
-	return gAgentHACK.getPosGlobalFromAgent(LLViewerCamera::getInstance()->getOrigin());
+	return gAgent.getPosGlobalFromAgent(LLViewerCamera::getInstance()->getOrigin());
 }
 
 //-----------------------------------------------------------------------------
@@ -1780,8 +1740,8 @@ LLVector3d LLAgentCamera::calcCameraPositionTargetGlobal(BOOL *hit_limit)
 {
 	// Compute base camera position and look-at points.
 	F32			camera_land_height;
-	LLVector3d	frame_center_global = gAgentHACK.mAvatarObject.isNull() ? gAgentHACK.getPositionGlobal() 
-															 : gAgentHACK.getPosGlobalFromAgent(gAgentHACK.mAvatarObject->mRoot.getWorldPosition());
+	LLVector3d	frame_center_global = gAgent.mAvatarObject.isNull() ? gAgent.getPositionGlobal() 
+															 : gAgent.getPosGlobalFromAgent(gAgent.mAvatarObject->mRoot.getWorldPosition());
 		
 	BOOL		isConstrained = FALSE;
 	LLVector3d	head_offset;
@@ -1796,32 +1756,32 @@ LLVector3d LLAgentCamera::calcCameraPositionTargetGlobal(BOOL *hit_limit)
 	}// End Ventrella
 	else if (mCameraMode == CAMERA_MODE_MOUSELOOK)
 	{
-		if (gAgentHACK.mAvatarObject.isNull() || gAgentHACK.mAvatarObject->mDrawable.isNull())
+		if (gAgent.mAvatarObject.isNull() || gAgent.mAvatarObject->mDrawable.isNull())
 		{
 			llwarns << "Null avatar drawable!" << llendl;
 			return LLVector3d::zero;
 		}
 		head_offset.clearVec();
-		if (gAgentHACK.mAvatarObject->isSitting() && gAgentHACK.mAvatarObject->getParent())
+		if (gAgent.mAvatarObject->isSitting() && gAgent.mAvatarObject->getParent())
 		{
-			gAgentHACK.mAvatarObject->updateHeadOffset();
-			head_offset.mdV[VX] = gAgentHACK.mAvatarObject->mHeadOffset.mV[VX];
-			head_offset.mdV[VY] = gAgentHACK.mAvatarObject->mHeadOffset.mV[VY];
-			head_offset.mdV[VZ] = gAgentHACK.mAvatarObject->mHeadOffset.mV[VZ] + 0.1f;
-			const LLMatrix4& mat = ((LLViewerObject*) gAgentHACK.mAvatarObject->getParent())->getRenderMatrix();
-			camera_position_global = gAgentHACK.getPosGlobalFromAgent
-								((gAgentHACK.mAvatarObject->getPosition()+
-								 LLVector3(head_offset)*gAgentHACK.mAvatarObject->getRotation()) * mat);
+			gAgent.mAvatarObject->updateHeadOffset();
+			head_offset.mdV[VX] = gAgent.mAvatarObject->mHeadOffset.mV[VX];
+			head_offset.mdV[VY] = gAgent.mAvatarObject->mHeadOffset.mV[VY];
+			head_offset.mdV[VZ] = gAgent.mAvatarObject->mHeadOffset.mV[VZ] + 0.1f;
+			const LLMatrix4& mat = ((LLViewerObject*) gAgent.mAvatarObject->getParent())->getRenderMatrix();
+			camera_position_global = gAgent.getPosGlobalFromAgent
+								((gAgent.mAvatarObject->getPosition()+
+								 LLVector3(head_offset)*gAgent.mAvatarObject->getRotation()) * mat);
 		}
 		else
 		{
-			head_offset.mdV[VZ] = gAgentHACK.mAvatarObject->mHeadOffset.mV[VZ];
-			if (gAgentHACK.mAvatarObject->isSitting())
+			head_offset.mdV[VZ] = gAgent.mAvatarObject->mHeadOffset.mV[VZ];
+			if (gAgent.mAvatarObject->isSitting())
 			{
 				head_offset.mdV[VZ] += 0.1;
 			}
-			camera_position_global = gAgentHACK.getPosGlobalFromAgent(gAgentHACK.mAvatarObject->getRenderPosition());//frame_center_global;
-			head_offset = head_offset * gAgentHACK.mAvatarObject->getRenderRotation();
+			camera_position_global = gAgent.getPosGlobalFromAgent(gAgent.mAvatarObject->getRenderPosition());//frame_center_global;
+			head_offset = head_offset * gAgent.mAvatarObject->getRenderRotation();
 			camera_position_global = camera_position_global + head_offset;
 		}
 	}
@@ -1831,8 +1791,8 @@ LLVector3d LLAgentCamera::calcCameraPositionTargetGlobal(BOOL *hit_limit)
 		F32 camera_distance = 0.f;
 
 		if (mSitCameraEnabled 
-			&& gAgentHACK.mAvatarObject.notNull() 
-			&& gAgentHACK.mAvatarObject->isSitting() 
+			&& gAgent.mAvatarObject.notNull() 
+			&& gAgent.mAvatarObject->isSitting() 
 			&& mSitCameraReferenceObject.notNull())
 		{
 			// sit camera
@@ -1841,30 +1801,30 @@ LLVector3d LLAgentCamera::calcCameraPositionTargetGlobal(BOOL *hit_limit)
 
 			LLVector3 target_pos = object_pos + (mSitCameraPos * object_rot);
 
-			camera_position_global = gAgentHACK.getPosGlobalFromAgent(target_pos);
+			camera_position_global = gAgent.getPosGlobalFromAgent(target_pos);
 		}
 		else
 		{
 			local_camera_offset = mCameraZoomFraction * getCameraOffsetInitial() * gSavedSettings.getF32("CameraOffsetScale");
 			
 			// are we sitting down?
-			if (gAgentHACK.mAvatarObject.notNull() && gAgentHACK.mAvatarObject->getParent())
+			if (gAgent.mAvatarObject.notNull() && gAgent.mAvatarObject->getParent())
 			{
-				LLQuaternion parent_rot = ((LLViewerObject*)gAgentHACK.mAvatarObject->getParent())->getRenderRotation();
+				LLQuaternion parent_rot = ((LLViewerObject*)gAgent.mAvatarObject->getParent())->getRenderRotation();
 				// slam agent coordinate frame to proper parent local version
-				LLVector3 at_axis = gAgentHACK.mFrameAgent.getAtAxis() * parent_rot;
+				LLVector3 at_axis = gAgent.mFrameAgent.getAtAxis() * parent_rot;
 				at_axis.mV[VZ] = 0.f;
 				at_axis.normalize();
-				gAgentHACK.resetAxes(at_axis * ~parent_rot);
+				gAgent.resetAxes(at_axis * ~parent_rot);
 
-				local_camera_offset = local_camera_offset * gAgentHACK.mFrameAgent.getQuaternion() * parent_rot;
+				local_camera_offset = local_camera_offset * gAgent.mFrameAgent.getQuaternion() * parent_rot;
 			}
 			else
 			{
-				local_camera_offset = gAgentHACK.mFrameAgent.rotateToAbsolute( local_camera_offset );
+				local_camera_offset = gAgent.mFrameAgent.rotateToAbsolute( local_camera_offset );
 			}
 
-			if (!mCameraCollidePlane.isExactlyZero() && (gAgentHACK.mAvatarObject.isNull() || !gAgentHACK.mAvatarObject->isSitting()))
+			if (!mCameraCollidePlane.isExactlyZero() && (gAgent.mAvatarObject.isNull() || !gAgent.mAvatarObject->isSitting()))
 			{
 				LLVector3 plane_normal;
 				plane_normal.setVec(mCameraCollidePlane.mV);
@@ -1877,7 +1837,7 @@ LLVector3d LLAgentCamera::calcCameraPositionTargetGlobal(BOOL *hit_limit)
 				
 				camera_distance = local_camera_offset.normalize();
 
-				F32 pos_dot_norm = gAgentHACK.getPosAgentFromGlobal(frame_center_global + head_offset) * plane_normal;
+				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])
@@ -1917,23 +1877,23 @@ LLVector3d LLAgentCamera::calcCameraPositionTargetGlobal(BOOL *hit_limit)
 			// set the global camera position
 			LLVector3d camera_offset;
 			
-			LLVector3 av_pos = gAgentHACK.mAvatarObject.isNull() ? LLVector3::zero : gAgentHACK.mAvatarObject->getRenderPosition();
+			LLVector3 av_pos = gAgent.mAvatarObject.isNull() ? LLVector3::zero : gAgent.mAvatarObject->getRenderPosition();
 			camera_offset.setVec( local_camera_offset );
 			camera_position_global = frame_center_global + head_offset + camera_offset;
 
-			if (gAgentHACK.mAvatarObject.notNull())
+			if (gAgent.mAvatarObject.notNull())
 			{
 				LLVector3d camera_lag_d;
 				F32 lag_interp = LLCriticalDamp::getInterpolant(CAMERA_LAG_HALF_LIFE);
 				LLVector3 target_lag;
-				LLVector3 vel = gAgentHACK.getVelocity();
+				LLVector3 vel = gAgent.getVelocity();
 
 				// lag by appropriate amount for flying
-				F32 time_in_air = gAgentHACK.mAvatarObject->mTimeInAir.getElapsedTimeF32();
-				if(!mCameraAnimating && gAgentHACK.mAvatarObject->mInAir && time_in_air > GROUND_TO_AIR_CAMERA_TRANSITION_START_TIME)
+				F32 time_in_air = gAgent.mAvatarObject->mTimeInAir.getElapsedTimeF32();
+				if(!mCameraAnimating && gAgent.mAvatarObject->mInAir && time_in_air > GROUND_TO_AIR_CAMERA_TRANSITION_START_TIME)
 				{
-					LLVector3 frame_at_axis = gAgentHACK.mFrameAgent.getAtAxis();
-					frame_at_axis -= projected_vec(frame_at_axis, gAgentHACK.getReferenceUpVector());
+					LLVector3 frame_at_axis = gAgent.mFrameAgent.getAtAxis();
+					frame_at_axis -= projected_vec(frame_at_axis, gAgent.getReferenceUpVector());
 					frame_at_axis.normalize();
 
 					//transition smoothly in air mode, to avoid camera pop
@@ -1942,7 +1902,7 @@ LLVector3d LLAgentCamera::calcCameraPositionTargetGlobal(BOOL *hit_limit)
 
 					lag_interp *= u;
 
-					if (gViewerWindow->getLeftMouseDown() && gViewerWindow->getLastPick().mObjectID == gAgentHACK.mAvatarObject->getID())
+					if (gViewerWindow->getLeftMouseDown() && gViewerWindow->getLastPick().mObjectID == gAgent.mAvatarObject->getID())
 					{
 						// disable camera lag when using mouse-directed steering
 						target_lag.clearVec();
@@ -2127,7 +2087,7 @@ F32 LLAgentCamera::getCameraMinOffGround()
 void LLAgentCamera::resetCamera()
 {
 	// Remove any pitch from the avatar
-	LLVector3 at = gAgentHACK.mFrameAgent.getAtAxis();
+	LLVector3 at = gAgent.mFrameAgent.getAtAxis();
 	at.mV[VZ] = 0.f;
 	at.normalize();
 	gAgent.resetAxes(at);
@@ -2151,14 +2111,14 @@ void LLAgentCamera::changeCameraToMouselook(BOOL animate)
 	gViewerWindow->getWindow()->resetBusyCount();
 
 	// unpause avatar animation
-	gAgentHACK.mPauseRequest = NULL;
+	gAgent.mPauseRequest = NULL;
 
 	LLToolMgr::getInstance()->setCurrentToolset(gMouselookToolset);
 
-	if (gAgentHACK.mAvatarObject.notNull())
+	if (gAgent.mAvatarObject.notNull())
 	{
-		gAgentHACK.mAvatarObject->stopMotion( ANIM_AGENT_BODY_NOISE );
-		gAgentHACK.mAvatarObject->stopMotion( ANIM_AGENT_BREATHE_ROT );
+		gAgent.mAvatarObject->stopMotion( ANIM_AGENT_BODY_NOISE );
+		gAgent.mAvatarObject->stopMotion( ANIM_AGENT_BREATHE_ROT );
 	}
 
 	//gViewerWindow->stopGrab();
@@ -2172,11 +2132,11 @@ void LLAgentCamera::changeCameraToMouselook(BOOL animate)
 		
 		mLastCameraMode = mCameraMode;
 		mCameraMode = CAMERA_MODE_MOUSELOOK;
-		U32 old_flags = gAgentHACK.mControlFlags;
-		gAgentHACK.setControlFlags(AGENT_CONTROL_MOUSELOOK);
-		if (old_flags != gAgentHACK.mControlFlags)
+		U32 old_flags = gAgent.mControlFlags;
+		gAgent.setControlFlags(AGENT_CONTROL_MOUSELOOK);
+		if (old_flags != gAgent.mControlFlags)
 		{
-			gAgentHACK.mbFlagsDirty = TRUE;
+			gAgent.mbFlagsDirty = TRUE;
 		}
 
 		if (animate)
@@ -2186,7 +2146,7 @@ void LLAgentCamera::changeCameraToMouselook(BOOL animate)
 		else
 		{
 			mCameraAnimating = FALSE;
-			gAgentHACK.endAnimationUpdateUI();
+			gAgent.endAnimationUpdateUI();
 		}
 	}
 }
@@ -2243,21 +2203,21 @@ void LLAgentCamera::changeCameraToFollow(BOOL animate)
 			LLToolMgr::getInstance()->setCurrentToolset(gBasicToolset);
 		}
 
-		if (gAgentHACK.mAvatarObject.notNull())
+		if (gAgent.mAvatarObject.notNull())
 		{
-			gAgentHACK.mAvatarObject->mPelvisp->setPosition(LLVector3::zero);
-			gAgentHACK.mAvatarObject->startMotion( ANIM_AGENT_BODY_NOISE );
-			gAgentHACK.mAvatarObject->startMotion( ANIM_AGENT_BREATHE_ROT );
+			gAgent.mAvatarObject->mPelvisp->setPosition(LLVector3::zero);
+			gAgent.mAvatarObject->startMotion( ANIM_AGENT_BODY_NOISE );
+			gAgent.mAvatarObject->startMotion( ANIM_AGENT_BREATHE_ROT );
 		}
 
 		// unpause avatar animation
-		gAgentHACK.mPauseRequest = NULL;
+		gAgent.mPauseRequest = NULL;
 
-		U32 old_flags = gAgentHACK.mControlFlags;
-		gAgentHACK.clearControlFlags(AGENT_CONTROL_MOUSELOOK);
-		if (old_flags != gAgentHACK.mControlFlags)
+		U32 old_flags = gAgent.mControlFlags;
+		gAgent.clearControlFlags(AGENT_CONTROL_MOUSELOOK);
+		if (old_flags != gAgent.mControlFlags)
 		{
-			gAgentHACK.mbFlagsDirty = TRUE;
+			gAgent.mbFlagsDirty = TRUE;
 		}
 
 		if (animate)
@@ -2267,7 +2227,7 @@ void LLAgentCamera::changeCameraToFollow(BOOL animate)
 		else
 		{
 			mCameraAnimating = FALSE;
-			gAgentHACK.endAnimationUpdateUI();
+			gAgent.endAnimationUpdateUI();
 		}
 	}
 }
@@ -2286,20 +2246,20 @@ void LLAgentCamera::changeCameraToThirdPerson(BOOL animate)
 
 	mCameraZoomFraction = INITIAL_ZOOM_FRACTION;
 
-	if (gAgentHACK.mAvatarObject.notNull())
+	if (gAgent.mAvatarObject.notNull())
 	{
-		if (!gAgentHACK.mAvatarObject->isSitting())
+		if (!gAgent.mAvatarObject->isSitting())
 		{
-			gAgentHACK.mAvatarObject->mPelvisp->setPosition(LLVector3::zero);
+			gAgent.mAvatarObject->mPelvisp->setPosition(LLVector3::zero);
 		}
-		gAgentHACK.mAvatarObject->startMotion( ANIM_AGENT_BODY_NOISE );
-		gAgentHACK.mAvatarObject->startMotion( ANIM_AGENT_BREATHE_ROT );
+		gAgent.mAvatarObject->startMotion( ANIM_AGENT_BODY_NOISE );
+		gAgent.mAvatarObject->startMotion( ANIM_AGENT_BREATHE_ROT );
 	}
 
 	LLVector3 at_axis;
 
 	// unpause avatar animation
-	gAgentHACK.mPauseRequest = NULL;
+	gAgent.mPauseRequest = NULL;
 
 	if( mCameraMode != CAMERA_MODE_THIRD_PERSON )
 	{
@@ -2317,30 +2277,30 @@ void LLAgentCamera::changeCameraToThirdPerson(BOOL animate)
 		}
 		mLastCameraMode = mCameraMode;
 		mCameraMode = CAMERA_MODE_THIRD_PERSON;
-		U32 old_flags = gAgentHACK.mControlFlags;
-		gAgentHACK.clearControlFlags(AGENT_CONTROL_MOUSELOOK);
-		if (old_flags != gAgentHACK.mControlFlags)
+		U32 old_flags = gAgent.mControlFlags;
+		gAgent.clearControlFlags(AGENT_CONTROL_MOUSELOOK);
+		if (old_flags != gAgent.mControlFlags)
 		{
-			gAgentHACK.mbFlagsDirty = TRUE;
+			gAgent.mbFlagsDirty = TRUE;
 		}
 
 	}
 
 	// Remove any pitch from the avatar
-	if (gAgentHACK.mAvatarObject.notNull() && gAgentHACK.mAvatarObject->getParent())
+	if (gAgent.mAvatarObject.notNull() && gAgent.mAvatarObject->getParent())
 	{
-		LLQuaternion obj_rot = ((LLViewerObject*)gAgentHACK.mAvatarObject->getParent())->getRenderRotation();
+		LLQuaternion obj_rot = ((LLViewerObject*)gAgent.mAvatarObject->getParent())->getRenderRotation();
 		at_axis = LLViewerCamera::getInstance()->getAtAxis();
 		at_axis.mV[VZ] = 0.f;
 		at_axis.normalize();
-		gAgentHACK.resetAxes(at_axis * ~obj_rot);
+		gAgent.resetAxes(at_axis * ~obj_rot);
 	}
 	else
 	{
-		at_axis = gAgentHACK.mFrameAgent.getAtAxis();
+		at_axis = gAgent.mFrameAgent.getAtAxis();
 		at_axis.mV[VZ] = 0.f;
 		at_axis.normalize();
-		gAgentHACK.resetAxes(at_axis);
+		gAgent.resetAxes(at_axis);
 	}
 
 
@@ -2351,7 +2311,7 @@ void LLAgentCamera::changeCameraToThirdPerson(BOOL animate)
 	else
 	{
 		mCameraAnimating = FALSE;
-		gAgentHACK.endAnimationUpdateUI();
+		gAgent.endAnimationUpdateUI();
 	}
 }
 
@@ -2365,7 +2325,7 @@ void LLAgentCamera::changeCameraToCustomizeAvatar(BOOL avatar_animate, BOOL came
 		return;
 	}
 
-	gAgentHACK.standUp(); // force stand up
+	gAgent.standUp(); // force stand up
 	gViewerWindow->getWindow()->resetBusyCount();
 
 	if (gFaceEditToolset)
@@ -2379,7 +2339,7 @@ void LLAgentCamera::changeCameraToCustomizeAvatar(BOOL avatar_animate, BOOL came
 	}
 
 	// Remove any pitch from the avatar
-	//LLVector3 at = gAgentHACK.mFrameAgent.getAtAxis();
+	//LLVector3 at = gAgent.mFrameAgent.getAtAxis();
 	//at.mV[VZ] = 0.f;
 	//at.normalize();
 	//gAgent.resetAxes(at);
@@ -2388,11 +2348,11 @@ void LLAgentCamera::changeCameraToCustomizeAvatar(BOOL avatar_animate, BOOL came
 	{
 		mLastCameraMode = mCameraMode;
 		mCameraMode = CAMERA_MODE_CUSTOMIZE_AVATAR;
-		U32 old_flags = gAgentHACK.mControlFlags;
-		gAgentHACK.clearControlFlags(AGENT_CONTROL_MOUSELOOK);
-		if (old_flags != gAgentHACK.mControlFlags)
+		U32 old_flags = gAgent.mControlFlags;
+		gAgent.clearControlFlags(AGENT_CONTROL_MOUSELOOK);
+		if (old_flags != gAgent.mControlFlags)
 		{
-			gAgentHACK.mbFlagsDirty = TRUE;
+			gAgent.mbFlagsDirty = TRUE;
 		}
 
 		gFocusMgr.setKeyboardFocus( NULL );
@@ -2401,20 +2361,20 @@ void LLAgentCamera::changeCameraToCustomizeAvatar(BOOL avatar_animate, BOOL came
 		LLVOAvatarSelf::onCustomizeStart();
 	}
 
-	if (gAgentHACK.mAvatarObject.notNull())
+	if (gAgent.mAvatarObject.notNull())
 	{
 		if(avatar_animate)
 		{
 			// Remove any pitch from the avatar
-			LLVector3 at = gAgentHACK.mFrameAgent.getAtAxis();
+			LLVector3 at = gAgent.mFrameAgent.getAtAxis();
 			at.mV[VZ] = 0.f;
 			at.normalize();
 			gAgent.resetAxes(at);
 
-			gAgentHACK.sendAnimationRequest(ANIM_AGENT_CUSTOMIZE, ANIM_REQUEST_START);
-			gAgentHACK.mCustomAnim = TRUE;
-			gAgentHACK.mAvatarObject->startMotion(ANIM_AGENT_CUSTOMIZE);
-			LLMotion* turn_motion = gAgentHACK.mAvatarObject->findMotion(ANIM_AGENT_CUSTOMIZE);
+			gAgent.sendAnimationRequest(ANIM_AGENT_CUSTOMIZE, ANIM_REQUEST_START);
+			gAgent.mCustomAnim = TRUE;
+			gAgent.mAvatarObject->startMotion(ANIM_AGENT_CUSTOMIZE);
+			LLMotion* turn_motion = gAgent.mAvatarObject->findMotion(ANIM_AGENT_CUSTOMIZE);
 
 			if (turn_motion)
 			{
@@ -2434,7 +2394,7 @@ void LLAgentCamera::changeCameraToCustomizeAvatar(BOOL avatar_animate, BOOL came
 	else
 	{
 		mCameraAnimating = FALSE;
-		gAgentHACK.endAnimationUpdateUI();
+		gAgent.endAnimationUpdateUI();
 	}
 
 }
@@ -2527,13 +2487,13 @@ void LLAgentCamera::setFocusGlobal(const LLVector3d& focus, const LLUUID &object
 	{
 		if (focus.isExactlyZero())
 		{
-			if (gAgentHACK.mAvatarObject.notNull())
+			if (gAgent.mAvatarObject.notNull())
 			{
-				mFocusTargetGlobal = gAgentHACK.getPosGlobalFromAgent(gAgentHACK.mAvatarObject->mHeadp->getWorldPosition());
+				mFocusTargetGlobal = gAgent.getPosGlobalFromAgent(gAgent.mAvatarObject->mHeadp->getWorldPosition());
 			}
 			else
 			{
-				mFocusTargetGlobal = gAgentHACK.getPositionGlobal();
+				mFocusTargetGlobal = gAgent.getPositionGlobal();
 			}
 			mCameraFocusOffsetTarget = getCameraPositionGlobal() - mFocusTargetGlobal;
 			mCameraFocusOffset = mCameraFocusOffsetTarget;
@@ -2559,12 +2519,12 @@ void LLAgentCamera::setFocusGlobal(const LLVector3d& focus, const LLUUID &object
 				}
 				else
 				{
-					setLookAt(LOOKAT_TARGET_FOCUS, focus_obj, (gAgentHACK.getPosAgentFromGlobal(focus) - focus_obj->getRenderPosition()) * ~focus_obj->getRenderRotation());
+					setLookAt(LOOKAT_TARGET_FOCUS, focus_obj, (gAgent.getPosAgentFromGlobal(focus) - focus_obj->getRenderPosition()) * ~focus_obj->getRenderRotation());
 				}
 			}
 			else
 			{
-				setLookAt(LOOKAT_TARGET_FOCUS, NULL, gAgentHACK.getPosAgentFromGlobal(mFocusTargetGlobal));
+				setLookAt(LOOKAT_TARGET_FOCUS, NULL, gAgent.getPosAgentFromGlobal(mFocusTargetGlobal));
 			}
 		}
 	}
@@ -2572,13 +2532,13 @@ void LLAgentCamera::setFocusGlobal(const LLVector3d& focus, const LLUUID &object
 	{
 		if (focus.isExactlyZero())
 		{
-			if (gAgentHACK.mAvatarObject.notNull())
+			if (gAgent.mAvatarObject.notNull())
 			{
-				mFocusTargetGlobal = gAgentHACK.getPosGlobalFromAgent(gAgentHACK.mAvatarObject->mHeadp->getWorldPosition());
+				mFocusTargetGlobal = gAgent.getPosGlobalFromAgent(gAgent.mAvatarObject->mHeadp->getWorldPosition());
 			}
 			else
 			{
-				mFocusTargetGlobal = gAgentHACK.getPositionGlobal();
+				mFocusTargetGlobal = gAgent.getPositionGlobal();
 			}
 		}
 		mCameraFocusOffsetTarget = (getCameraPositionGlobal() - mFocusTargetGlobal) / (1.f + mCameraFOVZoomFactor);;
@@ -2636,12 +2596,12 @@ void LLAgentCamera::setCameraPosAndFocusGlobal(const LLVector3d& camera_pos, con
 		}
 		else
 		{
-			setLookAt(LOOKAT_TARGET_FOCUS, mFocusObject, (gAgentHACK.getPosAgentFromGlobal(focus) - mFocusObject->getRenderPosition()) * ~mFocusObject->getRenderRotation());
+			setLookAt(LOOKAT_TARGET_FOCUS, mFocusObject, (gAgent.getPosAgentFromGlobal(focus) - mFocusObject->getRenderPosition()) * ~mFocusObject->getRenderRotation());
 		}
 	}
 	else
 	{
-		setLookAt(LOOKAT_TARGET_FOCUS, NULL, gAgentHACK.getPosAgentFromGlobal(mFocusTargetGlobal));
+		setLookAt(LOOKAT_TARGET_FOCUS, NULL, gAgent.getPosAgentFromGlobal(mFocusTargetGlobal));
 	}
 
 	if( mCameraAnimating )
@@ -2712,20 +2672,20 @@ void LLAgentCamera::setFocusOnAvatar(BOOL focus_on_avatar, BOOL animate)
 		if (mCameraMode == CAMERA_MODE_THIRD_PERSON)
 		{
 			LLVector3 at_axis;
-			if (gAgentHACK.mAvatarObject.notNull() && gAgentHACK.mAvatarObject->getParent())
+			if (gAgent.mAvatarObject.notNull() && gAgent.mAvatarObject->getParent())
 			{
-				LLQuaternion obj_rot = ((LLViewerObject*)gAgentHACK.mAvatarObject->getParent())->getRenderRotation();
+				LLQuaternion obj_rot = ((LLViewerObject*)gAgent.mAvatarObject->getParent())->getRenderRotation();
 				at_axis = LLViewerCamera::getInstance()->getAtAxis();
 				at_axis.mV[VZ] = 0.f;
 				at_axis.normalize();
-				gAgentHACK.resetAxes(at_axis * ~obj_rot);
+				gAgent.resetAxes(at_axis * ~obj_rot);
 			}
 			else
 			{
 				at_axis = LLViewerCamera::getInstance()->getAtAxis();
 				at_axis.mV[VZ] = 0.f;
 				at_axis.normalize();
-				gAgentHACK.resetAxes(at_axis);
+				gAgent.resetAxes(at_axis);
 			}
 		}
 	}
@@ -2733,7 +2693,7 @@ void LLAgentCamera::setFocusOnAvatar(BOOL focus_on_avatar, BOOL animate)
 	else if (mFocusOnAvatar && !focus_on_avatar)
 	{
 		// keep camera focus point consistent, even though it is now unlocked
-		setFocusGlobal(gAgentHACK.getPositionGlobal() + calcThirdPersonFocusOffset(), gAgent.getID());
+		setFocusGlobal(gAgent.getPositionGlobal() + calcThirdPersonFocusOffset(), gAgent.getID());
 	}
 	
 	mFocusOnAvatar = focus_on_avatar;
@@ -2747,10 +2707,10 @@ BOOL LLAgentCamera::setLookAt(ELookAtType target_type, LLViewerObject *object, L
 		LLViewerObject* parent = object;
 		while(parent)
 		{
-			if (parent == gAgentHACK.mAvatarObject)
+			if (parent == gAgent.mAvatarObject)
 			{
 				// looking at an attachment on ourselves, which we don't want to do
-				object = gAgentHACK.mAvatarObject;
+				object = gAgent.mAvatarObject;
 				position.clearVec();
 			}
 			parent = (LLViewerObject*)parent->getParent();
@@ -2759,7 +2719,7 @@ BOOL LLAgentCamera::setLookAt(ELookAtType target_type, LLViewerObject *object, L
 	if(!mLookAt || mLookAt->isDead())
 	{
 		mLookAt = (LLHUDEffectLookAt *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_LOOKAT);
-		mLookAt->setSourceObject(gAgentHACK.mAvatarObject);
+		mLookAt->setSourceObject(gAgent.mAvatarObject);
 	}
 
 	return mLookAt->setLookAt(target_type, object, position);
@@ -2776,7 +2736,7 @@ BOOL LLAgentCamera::setPointAt(EPointAtType target_type, LLViewerObject *object,
 	if(!mPointAt || mPointAt->isDead())
 	{
 		mPointAt = (LLHUDEffectPointAt *)LLHUDManager::getInstance()->createViewerEffect(LLHUDObject::LL_HUD_EFFECT_POINTAT);
-		mPointAt->setSourceObject(gAgentHACK.mAvatarObject);
+		mPointAt->setSourceObject(gAgent.mAvatarObject);
 	}
 
 	return mPointAt->setPointAt(target_type, object, position);
diff --git a/indra/newview/llagentcamera.h b/indra/newview/llagentcamera.h
index 6a0e8d372e..0b55b917d0 100644
--- a/indra/newview/llagentcamera.h
+++ b/indra/newview/llagentcamera.h
@@ -99,10 +99,6 @@ public:
  **                    INITIALIZATION
  **/
 
-	// SERAPH UNFILED
-public:
-	F32				mDrawDistance;
-
 	//--------------------------------------------------------------------
 	// Constructors / Destructors
 	//--------------------------------------------------------------------
@@ -139,9 +135,7 @@ private:
 	//--------------------------------------------------------------------
 public:
 	void switchCameraPreset(ECameraPreset preset);
-
 private:
-	
 	/** Determines default camera offset depending on the current camera preset */
 	LLVector3 getCameraOffsetInitial();
 
@@ -251,7 +245,7 @@ public:
 	void			startCameraAnimation();
 	void			stopCameraAnimation();
 private:
-	LLFrameTimer	mAnimationTimer; 	// Seconds that transition animation has been active // SERAPH agentCamera
+	LLFrameTimer	mAnimationTimer; 	// Seconds that transition animation has been active
 	F32				mAnimationDuration;	// In seconds
 	BOOL			mCameraAnimating;					// Camera is transitioning from one mode to another
 	LLVector3d		mAnimationCameraStartGlobal;		// Camera start position, global coords
@@ -347,6 +341,8 @@ public:
 	void			resetView(BOOL reset_camera = TRUE, BOOL change_camera = FALSE);
 	// Called on camera movement.  Unlocks camera from the default position behind the avatar.
 	void			unlockView();
+public:
+	F32				mDrawDistance;
 
 	//--------------------------------------------------------------------
 	// Mouselook
diff --git a/indra/newview/llappviewer.cpp b/indra/newview/llappviewer.cpp
index aaac36d557..80c32399ce 100644
--- a/indra/newview/llappviewer.cpp
+++ b/indra/newview/llappviewer.cpp
@@ -2509,9 +2509,9 @@ void LLAppViewer::cleanupSavedSettings()
 	gSavedSettings.setF32("MapScale", LLWorldMapView::sMapScale );
 
 	// Some things are cached in LLAgent.
-	if (gAgent.mInitialized)
+	if (gAgent.isInitialized())
 	{
-		gSavedSettings.setF32("RenderFarClip", gAgent.mDrawDistance);
+		gSavedSettings.setF32("RenderFarClip", gAgentCamera.mDrawDistance);
 	}
 }
 
diff --git a/indra/newview/lljoystickbutton.cpp b/indra/newview/lljoystickbutton.cpp
index 33f651284b..9e1dc3a4b0 100644
--- a/indra/newview/lljoystickbutton.cpp
+++ b/indra/newview/lljoystickbutton.cpp
@@ -627,24 +627,24 @@ void LLJoystickCameraTrack::onHeldDown()
 	if (dx > mVertSlopNear)
 	{
 		gAgentCamera.unlockView();
-		gAgent.setPanRightKey(getOrbitRate());
+		gAgentCamera.setPanRightKey(getOrbitRate());
 	}
 	else if (dx < -mVertSlopNear)
 	{
 		gAgentCamera.unlockView();
-		gAgent.setPanLeftKey(getOrbitRate());
+		gAgentCamera.setPanLeftKey(getOrbitRate());
 	}
 
 	// over/under rotation
 	if (dy > mVertSlopNear)
 	{
 		gAgentCamera.unlockView();
-		gAgent.setPanUpKey(getOrbitRate());
+		gAgentCamera.setPanUpKey(getOrbitRate());
 	}
 	else if (dy < -mVertSlopNear)
 	{
 		gAgentCamera.unlockView();
-		gAgent.setPanDownKey(getOrbitRate());
+		gAgentCamera.setPanDownKey(getOrbitRate());
 	}
 }
 
@@ -694,25 +694,25 @@ void LLJoystickCameraZoom::onHeldDown()
 	{
 		// Zoom in fast
 		gAgentCamera.unlockView();
-		gAgent.setOrbitInKey(FAST_RATE);
+		gAgentCamera.setOrbitInKey(FAST_RATE);
 	}
 	else if (dy > mVertSlopNear)
 	{
 		// Zoom in slow
 		gAgentCamera.unlockView();
-		gAgent.setOrbitInKey(getOrbitRate());
+		gAgentCamera.setOrbitInKey(getOrbitRate());
 	}
 	else if (dy < -mVertSlopFar)
 	{
 		// Zoom out fast
 		gAgentCamera.unlockView();
-		gAgent.setOrbitOutKey(FAST_RATE);
+		gAgentCamera.setOrbitOutKey(FAST_RATE);
 	}
 	else if (dy < -mVertSlopNear)
 	{
 		// Zoom out slow
 		gAgentCamera.unlockView();
-		gAgent.setOrbitOutKey(getOrbitRate());
+		gAgentCamera.setOrbitOutKey(getOrbitRate());
 	}
 }
 
diff --git a/indra/newview/llstartup.cpp b/indra/newview/llstartup.cpp
index 559cd624f7..c440a1b285 100644
--- a/indra/newview/llstartup.cpp
+++ b/indra/newview/llstartup.cpp
@@ -1174,7 +1174,7 @@ bool idle_startup()
 		// World initialization must be done after above window init
 
 		// User might have overridden far clip
-		LLWorld::getInstance()->setLandFarClip( gAgent.mDrawDistance );
+		LLWorld::getInstance()->setLandFarClip(gAgentCamera.mDrawDistance);
 
 		// Before we create the first region, we need to set the agent's mOriginGlobal
 		// This is necessary because creating objects before this is set will result in a
diff --git a/indra/newview/llviewercamera.cpp b/indra/newview/llviewercamera.cpp
index 0051f46716..aa82c216d9 100644
--- a/indra/newview/llviewercamera.cpp
+++ b/indra/newview/llviewercamera.cpp
@@ -37,6 +37,7 @@
 
 // Viewer includes
 #include "llagent.h"
+#include "llagentcamera.h"
 #include "llviewercontrol.h"
 #include "llviewerobjectlist.h"
 #include "llviewerregion.h"
@@ -354,7 +355,7 @@ void LLViewerCamera::setPerspective(BOOL for_selection,
 		}
 		else
 		{
-			z_far = gAgent.mDrawDistance;
+			z_far = gAgentCamera.mDrawDistance;
 		}
 	}
 	else
diff --git a/indra/newview/llviewercontrol.cpp b/indra/newview/llviewercontrol.cpp
index 5daea96123..23349ab916 100644
--- a/indra/newview/llviewercontrol.cpp
+++ b/indra/newview/llviewercontrol.cpp
@@ -41,6 +41,7 @@
 // For Listeners
 #include "llaudioengine.h"
 #include "llagent.h"
+#include "llagentcamera.h"
 #include "llconsole.h"
 #include "lldrawpoolterrain.h"
 #include "llflexibleobject.h"
@@ -102,7 +103,7 @@ static bool handleRenderAvatarMouselookChanged(const LLSD& newvalue)
 static bool handleRenderFarClipChanged(const LLSD& newvalue)
 {
 	F32 draw_distance = (F32) newvalue.asReal();
-	gAgent.mDrawDistance = draw_distance;
+	gAgentCamera.mDrawDistance = draw_distance;
 	LLWorld::getInstance()->setLandFarClip(draw_distance);
 	return true;
 }
diff --git a/indra/newview/llviewerdisplay.cpp b/indra/newview/llviewerdisplay.cpp
index 17816bc818..5a2b901bd7 100644
--- a/indra/newview/llviewerdisplay.cpp
+++ b/indra/newview/llviewerdisplay.cpp
@@ -175,7 +175,7 @@ void display_update_camera()
 
 	// Cut draw distance in half when customizing avatar,
 	// but on the viewer only.
-	F32 final_far = gAgent.mDrawDistance;
+	F32 final_far = gAgentCamera.mDrawDistance;
 	if (CAMERA_MODE_CUSTOMIZE_AVATAR == gAgentCamera.getCameraMode())
 	{
 		final_far *= 0.5f;
diff --git a/indra/newview/llviewerkeyboard.cpp b/indra/newview/llviewerkeyboard.cpp
index 4034d8c57d..cbec2c890f 100644
--- a/indra/newview/llviewerkeyboard.cpp
+++ b/indra/newview/llviewerkeyboard.cpp
@@ -281,7 +281,7 @@ void camera_spin_around_ccw( EKeystate s )
 {
 	if( KEYSTATE_UP == s  ) return;
 	gAgentCamera.unlockView();
-	gAgent.setOrbitLeftKey( get_orbit_rate() );
+	gAgentCamera.setOrbitLeftKey( get_orbit_rate() );
 }
 
 
@@ -289,7 +289,7 @@ void camera_spin_around_cw( EKeystate s )
 {
 	if( KEYSTATE_UP == s  ) return;
 	gAgentCamera.unlockView();
-	gAgent.setOrbitRightKey( get_orbit_rate() );
+	gAgentCamera.setOrbitRightKey( get_orbit_rate() );
 }
 
 void camera_spin_around_ccw_sitting( EKeystate s )
@@ -303,7 +303,7 @@ void camera_spin_around_ccw_sitting( EKeystate s )
 	else
 	{
 		//change camera but do not send keystrokes
-		gAgent.setOrbitLeftKey( get_orbit_rate() );
+		gAgentCamera.setOrbitLeftKey( get_orbit_rate() );
 	}
 }
 
@@ -319,7 +319,7 @@ void camera_spin_around_cw_sitting( EKeystate s )
 	else
 	{
 		//change camera but do not send keystrokes
-		gAgent.setOrbitRightKey( get_orbit_rate() );
+		gAgentCamera.setOrbitRightKey( get_orbit_rate() );
 	}
 }
 
@@ -328,7 +328,7 @@ void camera_spin_over( EKeystate s )
 {
 	if( KEYSTATE_UP == s  ) return;
 	gAgentCamera.unlockView();
-	gAgent.setOrbitUpKey( get_orbit_rate() );
+	gAgentCamera.setOrbitUpKey( get_orbit_rate() );
 }
 
 
@@ -336,7 +336,7 @@ void camera_spin_under( EKeystate s )
 {
 	if( KEYSTATE_UP == s  ) return;
 	gAgentCamera.unlockView();
-	gAgent.setOrbitDownKey( get_orbit_rate() );
+	gAgentCamera.setOrbitDownKey( get_orbit_rate() );
 }
 
 void camera_spin_over_sitting( EKeystate s )
@@ -350,7 +350,7 @@ void camera_spin_over_sitting( EKeystate s )
 	else
 	{
 		//change camera but do not send keystrokes
-		gAgent.setOrbitUpKey( get_orbit_rate() );
+		gAgentCamera.setOrbitUpKey( get_orbit_rate() );
 	}
 }
 
@@ -366,7 +366,7 @@ void camera_spin_under_sitting( EKeystate s )
 	else
 	{
 		//change camera but do not send keystrokes
-		gAgent.setOrbitDownKey( get_orbit_rate() );
+		gAgentCamera.setOrbitDownKey( get_orbit_rate() );
 	}
 }
 
@@ -374,7 +374,7 @@ void camera_move_forward( EKeystate s )
 {
 	if( KEYSTATE_UP == s  ) return;
 	gAgentCamera.unlockView();
-	gAgent.setOrbitInKey( get_orbit_rate() );
+	gAgentCamera.setOrbitInKey( get_orbit_rate() );
 }
 
 
@@ -382,7 +382,7 @@ void camera_move_backward( EKeystate s )
 {
 	if( KEYSTATE_UP == s  ) return;
 	gAgentCamera.unlockView();
-	gAgent.setOrbitOutKey( get_orbit_rate() );
+	gAgentCamera.setOrbitOutKey( get_orbit_rate() );
 }
 
 void camera_move_forward_sitting( EKeystate s )
@@ -394,7 +394,7 @@ void camera_move_forward_sitting( EKeystate s )
 	}
 	else
 	{
-		gAgent.setOrbitInKey( get_orbit_rate() );
+		gAgentCamera.setOrbitInKey( get_orbit_rate() );
 	}
 }
 
@@ -409,7 +409,7 @@ void camera_move_backward_sitting( EKeystate s )
 	}
 	else
 	{
-		gAgent.setOrbitOutKey( get_orbit_rate() );
+		gAgentCamera.setOrbitOutKey( get_orbit_rate() );
 	}
 }
 
@@ -417,56 +417,56 @@ void camera_pan_up( EKeystate s )
 {
 	if( KEYSTATE_UP == s  ) return;
 	gAgentCamera.unlockView();
-	gAgent.setPanUpKey( get_orbit_rate() );
+	gAgentCamera.setPanUpKey( get_orbit_rate() );
 }
 
 void camera_pan_down( EKeystate s )
 {
 	if( KEYSTATE_UP == s  ) return;
 	gAgentCamera.unlockView();
-	gAgent.setPanDownKey( get_orbit_rate() );
+	gAgentCamera.setPanDownKey( get_orbit_rate() );
 }
 
 void camera_pan_left( EKeystate s )
 {
 	if( KEYSTATE_UP == s  ) return;
 	gAgentCamera.unlockView();
-	gAgent.setPanLeftKey( get_orbit_rate() );
+	gAgentCamera.setPanLeftKey( get_orbit_rate() );
 }
 
 void camera_pan_right( EKeystate s )
 {
 	if( KEYSTATE_UP == s  ) return;
 	gAgentCamera.unlockView();
-	gAgent.setPanRightKey( get_orbit_rate() );
+	gAgentCamera.setPanRightKey( get_orbit_rate() );
 }
 
 void camera_pan_in( EKeystate s )
 {
 	if( KEYSTATE_UP == s  ) return;
 	gAgentCamera.unlockView();
-	gAgent.setPanInKey( get_orbit_rate() );
+	gAgentCamera.setPanInKey( get_orbit_rate() );
 }
 
 void camera_pan_out( EKeystate s )
 {
 	if( KEYSTATE_UP == s  ) return;
 	gAgentCamera.unlockView();
-	gAgent.setPanOutKey( get_orbit_rate() );
+	gAgentCamera.setPanOutKey( get_orbit_rate() );
 }
 
 void camera_move_forward_fast( EKeystate s )
 {
 	if( KEYSTATE_UP == s  ) return;
 	gAgentCamera.unlockView();
-	gAgent.setOrbitInKey(2.5f);
+	gAgentCamera.setOrbitInKey(2.5f);
 }
 
 void camera_move_backward_fast( EKeystate s )
 {
 	if( KEYSTATE_UP == s  ) return;
 	gAgentCamera.unlockView();
-	gAgent.setOrbitOutKey(2.5f);
+	gAgentCamera.setOrbitOutKey(2.5f);
 }
 
 
@@ -474,7 +474,7 @@ void edit_avatar_spin_ccw( EKeystate s )
 {
 	if( KEYSTATE_UP == s  ) return;
 	gMorphView->setCameraDrivenByKeys( TRUE );
-	gAgent.setOrbitLeftKey( get_orbit_rate() );
+	gAgentCamera.setOrbitLeftKey( get_orbit_rate() );
 	//gMorphView->orbitLeft( get_orbit_rate() );
 }
 
@@ -483,7 +483,7 @@ void edit_avatar_spin_cw( EKeystate s )
 {
 	if( KEYSTATE_UP == s  ) return;
 	gMorphView->setCameraDrivenByKeys( TRUE );
-	gAgent.setOrbitRightKey( get_orbit_rate() );
+	gAgentCamera.setOrbitRightKey( get_orbit_rate() );
 	//gMorphView->orbitRight( get_orbit_rate() );
 }
 
@@ -491,7 +491,7 @@ void edit_avatar_spin_over( EKeystate s )
 {
 	if( KEYSTATE_UP == s  ) return;
 	gMorphView->setCameraDrivenByKeys( TRUE );
-	gAgent.setOrbitUpKey( get_orbit_rate() );
+	gAgentCamera.setOrbitUpKey( get_orbit_rate() );
 	//gMorphView->orbitUp( get_orbit_rate() );
 }
 
@@ -500,7 +500,7 @@ void edit_avatar_spin_under( EKeystate s )
 {
 	if( KEYSTATE_UP == s  ) return;
 	gMorphView->setCameraDrivenByKeys( TRUE );
-	gAgent.setOrbitDownKey( get_orbit_rate() );
+	gAgentCamera.setOrbitDownKey( get_orbit_rate() );
 	//gMorphView->orbitDown( get_orbit_rate() );
 }
 
@@ -508,7 +508,7 @@ void edit_avatar_move_forward( EKeystate s )
 {
 	if( KEYSTATE_UP == s  ) return;
 	gMorphView->setCameraDrivenByKeys( TRUE );
-	gAgent.setOrbitInKey( get_orbit_rate() );
+	gAgentCamera.setOrbitInKey( get_orbit_rate() );
 	//gMorphView->orbitIn();
 }
 
@@ -517,7 +517,7 @@ void edit_avatar_move_backward( EKeystate s )
 {
 	if( KEYSTATE_UP == s  ) return;
 	gMorphView->setCameraDrivenByKeys( TRUE );
-	gAgent.setOrbitOutKey( get_orbit_rate() );
+	gAgentCamera.setOrbitOutKey( get_orbit_rate() );
 	//gMorphView->orbitOut();
 }
 
diff --git a/indra/newview/llviewermessage.cpp b/indra/newview/llviewermessage.cpp
index ea80dee05c..05dffb8107 100644
--- a/indra/newview/llviewermessage.cpp
+++ b/indra/newview/llviewermessage.cpp
@@ -3458,7 +3458,7 @@ void send_agent_update(BOOL force_send, BOOL send_reliable)
 		msg->addVector3Fast(_PREHASH_CameraAtAxis, LLViewerCamera::getInstance()->getAtAxis());
 		msg->addVector3Fast(_PREHASH_CameraLeftAxis, LLViewerCamera::getInstance()->getLeftAxis());
 		msg->addVector3Fast(_PREHASH_CameraUpAxis, LLViewerCamera::getInstance()->getUpAxis());
-		msg->addF32Fast(_PREHASH_Far, gAgent.mDrawDistance);
+		msg->addF32Fast(_PREHASH_Far, gAgentCamera.mDrawDistance);
 		
 		msg->addU32Fast(_PREHASH_ControlFlags, control_flags);
 
diff --git a/indra/newview/llviewerwindow.cpp b/indra/newview/llviewerwindow.cpp
index 8c6571aaf7..00c89457de 100644
--- a/indra/newview/llviewerwindow.cpp
+++ b/indra/newview/llviewerwindow.cpp
@@ -3656,7 +3656,7 @@ BOOL LLViewerWindow::mousePointOnLandGlobal(const S32 x, const S32 y, LLVector3d
 	LLVector3		probe_point_region;
 
 	// walk forwards to find the point
-	for (mouse_dir_scale = FIRST_PASS_STEP; mouse_dir_scale < gAgent.mDrawDistance; mouse_dir_scale += FIRST_PASS_STEP)
+	for (mouse_dir_scale = FIRST_PASS_STEP; mouse_dir_scale < gAgentCamera.mDrawDistance; mouse_dir_scale += FIRST_PASS_STEP)
 	{
 		LLVector3d mouse_direction_global_d;
 		mouse_direction_global_d.setVec(mouse_direction_global * mouse_dir_scale);