Merge remote-tracking branch 'origin/DRTVWR-600-maint-A' into brad/merge-maint-a-to-dev

1 files changed, 559 insertions, 559 deletions

diff --git a/indra/newview/llfollowcam.cpp b/indra/newview/llfollowcam.cpp
index 96cd8a05ff..89f77414a1 100644
--- a/indra/newview/llfollowcam.cpp
+++ b/indra/newview/llfollowcam.cpp
@@ -1,4 +1,4 @@
-/** 
+/**
  * @file llfollowcam.cpp
  * @author Jeffrey Ventrella
  * @brief LLFollowCam class implementation
@@ -6,21 +6,21 @@
  * $LicenseInfo:firstyear=2005&license=viewerlgpl$
  * Second Life Viewer Source Code
  * Copyright (C) 2010, Linden Research, Inc.
- * 
+ *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation;
  * version 2.1 of the License only.
- * 
+ *
  * This library is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
- * 
+ *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this library; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
+ *
  * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
  * $/LicenseInfo$
  */
@@ -32,103 +32,103 @@
 //-------------------------------------------------------
 // constants
 //-------------------------------------------------------
-const F32 FOLLOW_CAM_ZOOM_FACTOR			= 0.1f;
-const F32 FOLLOW_CAM_MIN_ZOOM_AMOUNT		= 0.1f;
-const F32 DISTANCE_EPSILON					= 0.0001f;
-const F32 DEFAULT_MAX_DISTANCE_FROM_SUBJECT	= 1000.0;	// this will be correctly set on me by my caller
+const F32 FOLLOW_CAM_ZOOM_FACTOR            = 0.1f;
+const F32 FOLLOW_CAM_MIN_ZOOM_AMOUNT        = 0.1f;
+const F32 DISTANCE_EPSILON                  = 0.0001f;
+const F32 DEFAULT_MAX_DISTANCE_FROM_SUBJECT = 1000.0;   // this will be correctly set on me by my caller
 
 //----------------------------------------------------------------------------------------
-// This is how slowly the camera position moves to its ideal position 
+// This is how slowly the camera position moves to its ideal position
 //----------------------------------------------------------------------------------------
-const F32 FOLLOW_CAM_MIN_POSITION_LAG		= 0.0f;		
-const F32 FOLLOW_CAM_DEFAULT_POSITION_LAG	= 0.1f;  
-const F32 FOLLOW_CAM_MAX_POSITION_LAG		= 3.0f;
+const F32 FOLLOW_CAM_MIN_POSITION_LAG       = 0.0f;
+const F32 FOLLOW_CAM_DEFAULT_POSITION_LAG   = 0.1f;
+const F32 FOLLOW_CAM_MAX_POSITION_LAG       = 3.0f;
 
 //----------------------------------------------------------------------------------------
 // This is how slowly the camera focus moves to its subject
 //----------------------------------------------------------------------------------------
-const F32 FOLLOW_CAM_MIN_FOCUS_LAG		= 0.0f;
-const F32 FOLLOW_CAM_DEFAULT_FOCUS_LAG	= 0.1f;
-const F32 FOLLOW_CAM_MAX_FOCUS_LAG		= 3.0f;
+const F32 FOLLOW_CAM_MIN_FOCUS_LAG      = 0.0f;
+const F32 FOLLOW_CAM_DEFAULT_FOCUS_LAG  = 0.1f;
+const F32 FOLLOW_CAM_MAX_FOCUS_LAG      = 3.0f;
 
 //----------------------------------------------------------------------------------------
 // This is far the position can get from its IDEAL POSITION before it starts getting pulled
 //----------------------------------------------------------------------------------------
-const F32 FOLLOW_CAM_MIN_POSITION_THRESHOLD		= 0.0f;
-const F32 FOLLOW_CAM_DEFAULT_POSITION_THRESHOLD	= 1.0f;
-const F32 FOLLOW_CAM_MAX_POSITION_THRESHOLD		= 4.0f;
+const F32 FOLLOW_CAM_MIN_POSITION_THRESHOLD     = 0.0f;
+const F32 FOLLOW_CAM_DEFAULT_POSITION_THRESHOLD = 1.0f;
+const F32 FOLLOW_CAM_MAX_POSITION_THRESHOLD     = 4.0f;
 
 //----------------------------------------------------------------------------------------
 // This is far the focus can get from the subject before it starts getting pulled
 //----------------------------------------------------------------------------------------
-const F32 FOLLOW_CAM_MIN_FOCUS_THRESHOLD		= 0.0f;
-const F32 FOLLOW_CAM_DEFAULT_FOCUS_THRESHOLD	= 1.0f;
-const F32 FOLLOW_CAM_MAX_FOCUS_THRESHOLD		= 4.0f;
+const F32 FOLLOW_CAM_MIN_FOCUS_THRESHOLD        = 0.0f;
+const F32 FOLLOW_CAM_DEFAULT_FOCUS_THRESHOLD    = 1.0f;
+const F32 FOLLOW_CAM_MAX_FOCUS_THRESHOLD        = 4.0f;
 
 //----------------------------------------------------------------------------------------
 // This is the distance the camera wants to be from the subject
 //----------------------------------------------------------------------------------------
-const F32 FOLLOW_CAM_MIN_DISTANCE		= 0.5f;
-const F32 FOLLOW_CAM_DEFAULT_DISTANCE	= 3.0f;
-//const F32 FOLLOW_CAM_MAX_DISTANCE		= 10.0f; // from now on I am using mMaxCameraDistantFromSubject
+const F32 FOLLOW_CAM_MIN_DISTANCE       = 0.5f;
+const F32 FOLLOW_CAM_DEFAULT_DISTANCE   = 3.0f;
+//const F32 FOLLOW_CAM_MAX_DISTANCE     = 10.0f; // from now on I am using mMaxCameraDistantFromSubject
 
 //----------------------------------------------------------------------------------------
 // this is an angluar value
-// It affects the angle that the camera rises (pitches) in relation 
+// It affects the angle that the camera rises (pitches) in relation
 // to the horizontal plane
 //----------------------------------------------------------------------------------------
-const F32 FOLLOW_CAM_MIN_PITCH		= -45.0f; 
-const F32 FOLLOW_CAM_DEFAULT_PITCH	=   0.0f;
-const F32 FOLLOW_CAM_MAX_PITCH		=  80.0f;	// keep under 90 degrees - avoid gimble lock!
+const F32 FOLLOW_CAM_MIN_PITCH      = -45.0f;
+const F32 FOLLOW_CAM_DEFAULT_PITCH  =   0.0f;
+const F32 FOLLOW_CAM_MAX_PITCH      =  80.0f;   // keep under 90 degrees - avoid gimble lock!
 
 
 //----------------------------------------------------------------------------------------
 // how high or low the camera considers its ideal focus to be (relative to its subject)
 //----------------------------------------------------------------------------------------
-const F32 FOLLOW_CAM_MIN_FOCUS_OFFSET		= -10.0f;
-const LLVector3 FOLLOW_CAM_DEFAULT_FOCUS_OFFSET	=  LLVector3(1.0f, 0.f, 0.f);
-const F32 FOLLOW_CAM_MAX_FOCUS_OFFSET		=  10.0f;
+const F32 FOLLOW_CAM_MIN_FOCUS_OFFSET       = -10.0f;
+const LLVector3 FOLLOW_CAM_DEFAULT_FOCUS_OFFSET =  LLVector3(1.0f, 0.f, 0.f);
+const F32 FOLLOW_CAM_MAX_FOCUS_OFFSET       =  10.0f;
 
 //----------------------------------------------------------------------------------------
 // This affects the rate at which the camera adjusts to stay behind the subject
 //----------------------------------------------------------------------------------------
-const F32 FOLLOW_CAM_MIN_BEHINDNESS_LAG		= 0.0f;
-const F32 FOLLOW_CAM_DEFAULT_BEHINDNESS_LAG		= 0.f;
-const F32 FOLLOW_CAM_MAX_BEHINDNESS_LAG		= 3.0f;
+const F32 FOLLOW_CAM_MIN_BEHINDNESS_LAG     = 0.0f;
+const F32 FOLLOW_CAM_DEFAULT_BEHINDNESS_LAG     = 0.f;
+const F32 FOLLOW_CAM_MAX_BEHINDNESS_LAG     = 3.0f;
 
 //---------------------------------------------------------------------------------------------------------------------
 // in  degrees: This is the size of the pie slice behind the subject matter within which the camera is free to move
 //---------------------------------------------------------------------------------------------------------------------
-const F32 FOLLOW_CAM_MIN_BEHINDNESS_ANGLE		= 0.0f;
-const F32 FOLLOW_CAM_DEFAULT_BEHINDNESS_ANGLE	= 10.0f;
-const F32 FOLLOW_CAM_MAX_BEHINDNESS_ANGLE		= 180.0f;
-const F32 FOLLOW_CAM_BEHINDNESS_EPSILON			= 1.0f;
+const F32 FOLLOW_CAM_MIN_BEHINDNESS_ANGLE       = 0.0f;
+const F32 FOLLOW_CAM_DEFAULT_BEHINDNESS_ANGLE   = 10.0f;
+const F32 FOLLOW_CAM_MAX_BEHINDNESS_ANGLE       = 180.0f;
+const F32 FOLLOW_CAM_BEHINDNESS_EPSILON         = 1.0f;
 
 //------------------------------------
 // Constructor
 //------------------------------------
 LLFollowCamParams::LLFollowCamParams()
 {
-	mMaxCameraDistantFromSubject		= DEFAULT_MAX_DISTANCE_FROM_SUBJECT;
-	mPositionLocked						= false;
-	mFocusLocked						= false;
-	mUsePosition						= false;
-	mUseFocus							= false;
-
-	//------------------------------------------------------
-	// setting the attributes to their defaults
-	//------------------------------------------------------
-	setPositionLag		( FOLLOW_CAM_DEFAULT_POSITION_LAG			);
-	setFocusLag			( FOLLOW_CAM_DEFAULT_FOCUS_LAG				);
-	setPositionThreshold( FOLLOW_CAM_DEFAULT_POSITION_THRESHOLD		);
-	setFocusThreshold	( FOLLOW_CAM_DEFAULT_FOCUS_THRESHOLD		);
-	setBehindnessLag	( FOLLOW_CAM_DEFAULT_BEHINDNESS_LAG		);
-	setDistance			( FOLLOW_CAM_DEFAULT_DISTANCE				);
-	setPitch			( FOLLOW_CAM_DEFAULT_PITCH					);
-	setFocusOffset		( FOLLOW_CAM_DEFAULT_FOCUS_OFFSET	);
-	setBehindnessAngle	( FOLLOW_CAM_DEFAULT_BEHINDNESS_ANGLE		);
-	setPositionThreshold( FOLLOW_CAM_DEFAULT_POSITION_THRESHOLD		);
-	setFocusThreshold	( FOLLOW_CAM_DEFAULT_FOCUS_THRESHOLD		);
+    mMaxCameraDistantFromSubject        = DEFAULT_MAX_DISTANCE_FROM_SUBJECT;
+    mPositionLocked                     = false;
+    mFocusLocked                        = false;
+    mUsePosition                        = false;
+    mUseFocus                           = false;
+
+    //------------------------------------------------------
+    // setting the attributes to their defaults
+    //------------------------------------------------------
+    setPositionLag      ( FOLLOW_CAM_DEFAULT_POSITION_LAG           );
+    setFocusLag         ( FOLLOW_CAM_DEFAULT_FOCUS_LAG              );
+    setPositionThreshold( FOLLOW_CAM_DEFAULT_POSITION_THRESHOLD     );
+    setFocusThreshold   ( FOLLOW_CAM_DEFAULT_FOCUS_THRESHOLD        );
+    setBehindnessLag    ( FOLLOW_CAM_DEFAULT_BEHINDNESS_LAG     );
+    setDistance         ( FOLLOW_CAM_DEFAULT_DISTANCE               );
+    setPitch            ( FOLLOW_CAM_DEFAULT_PITCH                  );
+    setFocusOffset      ( FOLLOW_CAM_DEFAULT_FOCUS_OFFSET   );
+    setBehindnessAngle  ( FOLLOW_CAM_DEFAULT_BEHINDNESS_ANGLE       );
+    setPositionThreshold( FOLLOW_CAM_DEFAULT_POSITION_THRESHOLD     );
+    setFocusThreshold   ( FOLLOW_CAM_DEFAULT_FOCUS_THRESHOLD        );
 
 }
 
@@ -139,305 +139,305 @@ LLFollowCamParams::~LLFollowCamParams() { }
 //---------------------------------------------------------
 
 //---------------------------------------------------------
-void LLFollowCamParams::setPositionLag( F32 p ) 
-{ 
-	mPositionLag = llclamp(p, FOLLOW_CAM_MIN_POSITION_LAG, FOLLOW_CAM_MAX_POSITION_LAG); 
+void LLFollowCamParams::setPositionLag( F32 p )
+{
+    mPositionLag = llclamp(p, FOLLOW_CAM_MIN_POSITION_LAG, FOLLOW_CAM_MAX_POSITION_LAG);
 }
 
 
 //---------------------------------------------------------
-void LLFollowCamParams::setFocusLag( F32 f ) 
-{ 
-	mFocusLag = llclamp(f, FOLLOW_CAM_MIN_FOCUS_LAG, FOLLOW_CAM_MAX_FOCUS_LAG); 
+void LLFollowCamParams::setFocusLag( F32 f )
+{
+    mFocusLag = llclamp(f, FOLLOW_CAM_MIN_FOCUS_LAG, FOLLOW_CAM_MAX_FOCUS_LAG);
 }
 
 
 //---------------------------------------------------------
-void LLFollowCamParams::setPositionThreshold( F32 p ) 
-{ 
-	mPositionThreshold = llclamp(p, FOLLOW_CAM_MIN_POSITION_THRESHOLD, FOLLOW_CAM_MAX_POSITION_THRESHOLD); 
+void LLFollowCamParams::setPositionThreshold( F32 p )
+{
+    mPositionThreshold = llclamp(p, FOLLOW_CAM_MIN_POSITION_THRESHOLD, FOLLOW_CAM_MAX_POSITION_THRESHOLD);
 }
 
 
 //---------------------------------------------------------
-void LLFollowCamParams::setFocusThreshold( F32 f ) 
-{ 
-	mFocusThreshold = llclamp(f, FOLLOW_CAM_MIN_FOCUS_THRESHOLD, FOLLOW_CAM_MAX_FOCUS_THRESHOLD); 
+void LLFollowCamParams::setFocusThreshold( F32 f )
+{
+    mFocusThreshold = llclamp(f, FOLLOW_CAM_MIN_FOCUS_THRESHOLD, FOLLOW_CAM_MAX_FOCUS_THRESHOLD);
 }
 
 
 //---------------------------------------------------------
-void LLFollowCamParams::setPitch( F32 p ) 
-{ 
-	mPitch = llclamp(p, FOLLOW_CAM_MIN_PITCH, FOLLOW_CAM_MAX_PITCH); 
+void LLFollowCamParams::setPitch( F32 p )
+{
+    mPitch = llclamp(p, FOLLOW_CAM_MIN_PITCH, FOLLOW_CAM_MAX_PITCH);
 }
 
 
 //---------------------------------------------------------
-void LLFollowCamParams::setBehindnessLag( F32 b ) 
-{ 
-	mBehindnessLag = llclamp(b, FOLLOW_CAM_MIN_BEHINDNESS_LAG, FOLLOW_CAM_MAX_BEHINDNESS_LAG); 
+void LLFollowCamParams::setBehindnessLag( F32 b )
+{
+    mBehindnessLag = llclamp(b, FOLLOW_CAM_MIN_BEHINDNESS_LAG, FOLLOW_CAM_MAX_BEHINDNESS_LAG);
 }
 
 //---------------------------------------------------------
-void LLFollowCamParams::setBehindnessAngle( F32 b ) 
-{ 
-	mBehindnessMaxAngle = llclamp(b, FOLLOW_CAM_MIN_BEHINDNESS_ANGLE, FOLLOW_CAM_MAX_BEHINDNESS_ANGLE); 
+void LLFollowCamParams::setBehindnessAngle( F32 b )
+{
+    mBehindnessMaxAngle = llclamp(b, FOLLOW_CAM_MIN_BEHINDNESS_ANGLE, FOLLOW_CAM_MAX_BEHINDNESS_ANGLE);
 }
 
 //---------------------------------------------------------
-void LLFollowCamParams::setDistance( F32 d ) 
-{ 
-	mDistance = llclamp(d, FOLLOW_CAM_MIN_DISTANCE, mMaxCameraDistantFromSubject); 
+void LLFollowCamParams::setDistance( F32 d )
+{
+    mDistance = llclamp(d, FOLLOW_CAM_MIN_DISTANCE, mMaxCameraDistantFromSubject);
 }
 
 //---------------------------------------------------------
-void LLFollowCamParams::setPositionLocked( bool l ) 
+void LLFollowCamParams::setPositionLocked( bool l )
 {
-	mPositionLocked = l;
+    mPositionLocked = l;
 }
 
 //---------------------------------------------------------
-void LLFollowCamParams::setFocusLocked( bool l ) 
+void LLFollowCamParams::setFocusLocked( bool l )
 {
-	mFocusLocked = l;
+    mFocusLocked = l;
 
 }
 
 //---------------------------------------------------------
-void LLFollowCamParams::setFocusOffset( const LLVector3& v ) 
-{ 
-	mFocusOffset = v; 
-	mFocusOffset.clamp(FOLLOW_CAM_MIN_FOCUS_OFFSET, FOLLOW_CAM_MAX_FOCUS_OFFSET);
+void LLFollowCamParams::setFocusOffset( const LLVector3& v )
+{
+    mFocusOffset = v;
+    mFocusOffset.clamp(FOLLOW_CAM_MIN_FOCUS_OFFSET, FOLLOW_CAM_MAX_FOCUS_OFFSET);
 }
 
 //---------------------------------------------------------
-void LLFollowCamParams::setPosition( const LLVector3& p ) 
-{ 
-	mUsePosition = true;
-	mPosition = p;
+void LLFollowCamParams::setPosition( const LLVector3& p )
+{
+    mUsePosition = true;
+    mPosition = p;
 }
 
 //---------------------------------------------------------
-void LLFollowCamParams::setFocus( const LLVector3& f ) 
-{ 
-	mUseFocus = true;
-	mFocus = f;
+void LLFollowCamParams::setFocus( const LLVector3& f )
+{
+    mUseFocus = true;
+    mFocus = f;
 }
 
 //---------------------------------------------------------
 // buncho get methods
 //---------------------------------------------------------
-F32			LLFollowCamParams::getPositionLag		() const { return mPositionLag;			}
-F32			LLFollowCamParams::getFocusLag			() const { return mFocusLag;			}
-F32			LLFollowCamParams::getPositionThreshold	() const { return mPositionThreshold;	}
-F32			LLFollowCamParams::getFocusThreshold	() const { return mFocusThreshold;		}
-F32			LLFollowCamParams::getDistance			() const { return mDistance;			}
-F32			LLFollowCamParams::getPitch				() const { return mPitch;				}
-LLVector3	LLFollowCamParams::getFocusOffset		() const { return mFocusOffset;			}
-F32			LLFollowCamParams::getBehindnessAngle	() const { return mBehindnessMaxAngle;	}
-F32			LLFollowCamParams::getBehindnessLag		() const { return mBehindnessLag;		}
-LLVector3	LLFollowCamParams::getPosition			() const { return mPosition;			}
-LLVector3	LLFollowCamParams::getFocus				() const { return mFocus;				}
-bool		LLFollowCamParams::getPositionLocked	() const { return mPositionLocked;		}
-bool		LLFollowCamParams::getFocusLocked		() const { return mFocusLocked;			}
+F32         LLFollowCamParams::getPositionLag       () const { return mPositionLag;         }
+F32         LLFollowCamParams::getFocusLag          () const { return mFocusLag;            }
+F32         LLFollowCamParams::getPositionThreshold () const { return mPositionThreshold;   }
+F32         LLFollowCamParams::getFocusThreshold    () const { return mFocusThreshold;      }
+F32         LLFollowCamParams::getDistance          () const { return mDistance;            }
+F32         LLFollowCamParams::getPitch             () const { return mPitch;               }
+LLVector3   LLFollowCamParams::getFocusOffset       () const { return mFocusOffset;         }
+F32         LLFollowCamParams::getBehindnessAngle   () const { return mBehindnessMaxAngle;  }
+F32         LLFollowCamParams::getBehindnessLag     () const { return mBehindnessLag;       }
+LLVector3   LLFollowCamParams::getPosition          () const { return mPosition;            }
+LLVector3   LLFollowCamParams::getFocus             () const { return mFocus;               }
+bool        LLFollowCamParams::getPositionLocked    () const { return mPositionLocked;      }
+bool        LLFollowCamParams::getFocusLocked       () const { return mFocusLocked;         }
 
 //------------------------------------
 // Constructor
 //------------------------------------
 LLFollowCam::LLFollowCam() : LLFollowCamParams()
 {
-	mUpVector							= LLVector3::z_axis;
-	mSubjectPosition					= LLVector3::zero;
-	mSubjectRotation					= LLQuaternion::DEFAULT;
+    mUpVector                           = LLVector3::z_axis;
+    mSubjectPosition                    = LLVector3::zero;
+    mSubjectRotation                    = LLQuaternion::DEFAULT;
 
-	mZoomedToMinimumDistance			= false;
-	mPitchCos = mPitchSin = 0.f;
-	mPitchSineAndCosineNeedToBeUpdated	= true; 
+    mZoomedToMinimumDistance            = false;
+    mPitchCos = mPitchSin = 0.f;
+    mPitchSineAndCosineNeedToBeUpdated  = true;
 
-	mSimulatedDistance = mDistance;
+    mSimulatedDistance = mDistance;
 }
 
 void LLFollowCam::copyParams(LLFollowCamParams& params)
 {
-	setPositionLag(params.getPositionLag());
-	setFocusLag(params.getFocusLag());
-	setFocusThreshold( params.getFocusThreshold());
-	setPositionThreshold(params.getPositionThreshold());
-	setPitch(params.getPitch());
-	setFocusOffset(params.getFocusOffset());
-	setBehindnessAngle(params.getBehindnessAngle());
-	setBehindnessLag(params.getBehindnessLag());
-
-	setPositionLocked(params.getPositionLocked());
-	setFocusLocked(params.getFocusLocked());
-
-	setDistance(params.getDistance());	
-	if (params.getUsePosition())
-	{
-		setPosition(params.getPosition());
-	}
-	if (params.getUseFocus())
-	{
-		setFocus(params.getFocus());
-	}
+    setPositionLag(params.getPositionLag());
+    setFocusLag(params.getFocusLag());
+    setFocusThreshold( params.getFocusThreshold());
+    setPositionThreshold(params.getPositionThreshold());
+    setPitch(params.getPitch());
+    setFocusOffset(params.getFocusOffset());
+    setBehindnessAngle(params.getBehindnessAngle());
+    setBehindnessLag(params.getBehindnessLag());
+
+    setPositionLocked(params.getPositionLocked());
+    setFocusLocked(params.getFocusLocked());
+
+    setDistance(params.getDistance());
+    if (params.getUsePosition())
+    {
+        setPosition(params.getPosition());
+    }
+    if (params.getUseFocus())
+    {
+        setFocus(params.getFocus());
+    }
 }
 
 //---------------------------------------------------------------------------------------------------------
 void LLFollowCam::update()
 {
-	//####################################################################################
-	// update Focus
-	//####################################################################################
-	LLVector3 offsetSubjectPosition = mSubjectPosition + (mFocusOffset * mSubjectRotation);
-
-	LLVector3 simulated_pos_agent = gAgent.getPosAgentFromGlobal(mSimulatedPositionGlobal);
-	LLVector3 vectorFromCameraToSubject = offsetSubjectPosition - simulated_pos_agent;
-	F32 distanceFromCameraToSubject = vectorFromCameraToSubject.magVec();
-
-	LLVector3 whereFocusWantsToBe = mFocus;
-	LLVector3 focus_pt_agent = gAgent.getPosAgentFromGlobal(mSimulatedFocusGlobal);
-	if ( mFocusLocked ) // if focus is locked, only relative focus needs to be updated
-	{
-		mRelativeFocus = (focus_pt_agent - mSubjectPosition) * ~mSubjectRotation;
-	}
-	else
-	{
-		LLVector3 focusOffset = offsetSubjectPosition - focus_pt_agent;
-		F32 focusOffsetDistance = focusOffset.magVec();
-
-		LLVector3 focusOffsetDirection = focusOffset / focusOffsetDistance;
-		whereFocusWantsToBe = focus_pt_agent + 
-			(focusOffsetDirection * (focusOffsetDistance - mFocusThreshold));
-		if ( focusOffsetDistance > mFocusThreshold )
-		{
-			// this version normalizes focus threshold by distance 
-			// so that the effect is not changed with distance
-			/*
-			F32 focusThresholdNormalizedByDistance = distanceFromCameraToSubject * mFocusThreshold;
-			if ( focusOffsetDistance > focusThresholdNormalizedByDistance )
-			{
-				LLVector3 focusOffsetDirection = focusOffset / focusOffsetDistance;
-				F32 force = focusOffsetDistance - focusThresholdNormalizedByDistance;
-			*/
-
-			F32 focusLagLerp = LLSmoothInterpolation::getInterpolant( mFocusLag );
-			focus_pt_agent = lerp( focus_pt_agent, whereFocusWantsToBe, focusLagLerp );
-			mSimulatedFocusGlobal = gAgent.getPosGlobalFromAgent(focus_pt_agent);
-		}
-		mRelativeFocus = lerp(mRelativeFocus, (focus_pt_agent - mSubjectPosition) * ~mSubjectRotation, LLSmoothInterpolation::getInterpolant(0.05f));
-	}// if focus is not locked ---------------------------------------------
-
-
-	LLVector3 whereCameraPositionWantsToBe = gAgent.getPosAgentFromGlobal(mSimulatedPositionGlobal);
-	if (  mPositionLocked )
-	{
-		mRelativePos = (whereCameraPositionWantsToBe - mSubjectPosition) * ~mSubjectRotation;
-	}
-	else
-	{
-		//####################################################################################
-		// update Position
-		//####################################################################################
-		//-------------------------------------------------------------------------
-		// I determine the horizontal vector from the camera to the subject
-		//-------------------------------------------------------------------------
-		LLVector3 horizontalVectorFromCameraToSubject = vectorFromCameraToSubject;
-		horizontalVectorFromCameraToSubject.mV[VZ] = 0.0f;
-
-		//---------------------------------------------------------
-		// Now I determine the horizontal distance
-		//---------------------------------------------------------
-		F32 horizontalDistanceFromCameraToSubject = horizontalVectorFromCameraToSubject.magVec();  
-
-		//---------------------------------------------------------
-		// Then I get the (normalized) horizontal direction...
-		//---------------------------------------------------------
-		LLVector3 horizontalDirectionFromCameraToSubject;	
-		if ( horizontalDistanceFromCameraToSubject < DISTANCE_EPSILON )
-		{
-			// make sure we still have a normalized vector if distance is really small 
-			// (this case is rare and fleeting)
-			horizontalDirectionFromCameraToSubject = LLVector3::z_axis;
-		}
-		else
-		{
-			// I'm not using the "normalize" method, because I can just divide by horizontalDistanceFromCameraToSubject
-			horizontalDirectionFromCameraToSubject = horizontalVectorFromCameraToSubject / horizontalDistanceFromCameraToSubject;
-		}
-
-		//------------------------------------------------------------------------------------------------------------
-		// Here is where I determine an offset relative to subject position in oder to set the ideal position. 
-		//------------------------------------------------------------------------------------------------------------
-		if ( mPitchSineAndCosineNeedToBeUpdated )
-		{
-			calculatePitchSineAndCosine();
-			mPitchSineAndCosineNeedToBeUpdated = false;
-		}
-
-		LLVector3 positionOffsetFromSubject;
-		positionOffsetFromSubject.setVec
-			( 
-				horizontalDirectionFromCameraToSubject.mV[ VX ] * mPitchCos,
-				horizontalDirectionFromCameraToSubject.mV[ VY ] * mPitchCos,
-				-mPitchSin
-			);
-
-		positionOffsetFromSubject *= mSimulatedDistance;
-
-		//----------------------------------------------------------------------
-		// Finally, ideal position is set by taking the subject position and 
-		// extending the positionOffsetFromSubject from that
-		//----------------------------------------------------------------------
-		LLVector3 idealCameraPosition = offsetSubjectPosition - positionOffsetFromSubject;
-
-		//--------------------------------------------------------------------------------
-		// Now I prepare to move the current camera position towards its ideal position...
-		//--------------------------------------------------------------------------------
-		LLVector3 vectorFromPositionToIdealPosition = idealCameraPosition - simulated_pos_agent;
-		F32 distanceFromPositionToIdealPosition = vectorFromPositionToIdealPosition.magVec();
-		
-		//put this inside of the block?		
-		LLVector3 normalFromPositionToIdealPosition = vectorFromPositionToIdealPosition / distanceFromPositionToIdealPosition;
-		
-		whereCameraPositionWantsToBe = simulated_pos_agent + 
-			(normalFromPositionToIdealPosition * (distanceFromPositionToIdealPosition - mPositionThreshold));
-		//-------------------------------------------------------------------------------------------------
-		// The following method takes the target camera position and resets it so that it stays "behind" the subject, 
-		// using behindness angle and behindness force as parameters affecting the exact behavior
-		//-------------------------------------------------------------------------------------------------
-		if ( distanceFromPositionToIdealPosition > mPositionThreshold )
-		{
-			F32 positionPullLerp = LLSmoothInterpolation::getInterpolant( mPositionLag );
-			simulated_pos_agent = lerp( simulated_pos_agent, whereCameraPositionWantsToBe, positionPullLerp );
-		}
-
-		//--------------------------------------------------------------------
-		// don't let the camera get farther than its official max distance
-		//--------------------------------------------------------------------
-		if ( distanceFromCameraToSubject > mMaxCameraDistantFromSubject )
-		{
-			LLVector3 directionFromCameraToSubject = vectorFromCameraToSubject / distanceFromCameraToSubject;
-			simulated_pos_agent = offsetSubjectPosition - directionFromCameraToSubject * mMaxCameraDistantFromSubject;
-		}
-
-		////-------------------------------------------------------------------------------------------------
-		//// The following method takes mSimulatedPositionGlobal and resets it so that it stays "behind" the subject, 
-		//// using behindness angle and behindness force as parameters affecting the exact behavior
-		////-------------------------------------------------------------------------------------------------
-		updateBehindnessConstraint(gAgent.getPosAgentFromGlobal(mSimulatedFocusGlobal), simulated_pos_agent);
-		mSimulatedPositionGlobal = gAgent.getPosGlobalFromAgent(simulated_pos_agent);
-
-		mRelativePos = lerp(mRelativePos, (simulated_pos_agent - mSubjectPosition) * ~mSubjectRotation, LLSmoothInterpolation::getInterpolant(0.05f));
-	} // if position is not locked -----------------------------------------------------------
-
-
-	//####################################################################################
-	// update UpVector
-	//####################################################################################
-	// this just points upward for now, but I anticipate future effects requiring 
-	// some rolling ("banking" effects for fun, swoopy vehicles, etc.)
-	mUpVector = LLVector3::z_axis;
+    //####################################################################################
+    // update Focus
+    //####################################################################################
+    LLVector3 offsetSubjectPosition = mSubjectPosition + (mFocusOffset * mSubjectRotation);
+
+    LLVector3 simulated_pos_agent = gAgent.getPosAgentFromGlobal(mSimulatedPositionGlobal);
+    LLVector3 vectorFromCameraToSubject = offsetSubjectPosition - simulated_pos_agent;
+    F32 distanceFromCameraToSubject = vectorFromCameraToSubject.magVec();
+
+    LLVector3 whereFocusWantsToBe = mFocus;
+    LLVector3 focus_pt_agent = gAgent.getPosAgentFromGlobal(mSimulatedFocusGlobal);
+    if ( mFocusLocked ) // if focus is locked, only relative focus needs to be updated
+    {
+        mRelativeFocus = (focus_pt_agent - mSubjectPosition) * ~mSubjectRotation;
+    }
+    else
+    {
+        LLVector3 focusOffset = offsetSubjectPosition - focus_pt_agent;
+        F32 focusOffsetDistance = focusOffset.magVec();
+
+        LLVector3 focusOffsetDirection = focusOffset / focusOffsetDistance;
+        whereFocusWantsToBe = focus_pt_agent +
+            (focusOffsetDirection * (focusOffsetDistance - mFocusThreshold));
+        if ( focusOffsetDistance > mFocusThreshold )
+        {
+            // this version normalizes focus threshold by distance
+            // so that the effect is not changed with distance
+            /*
+            F32 focusThresholdNormalizedByDistance = distanceFromCameraToSubject * mFocusThreshold;
+            if ( focusOffsetDistance > focusThresholdNormalizedByDistance )
+            {
+                LLVector3 focusOffsetDirection = focusOffset / focusOffsetDistance;
+                F32 force = focusOffsetDistance - focusThresholdNormalizedByDistance;
+            */
+
+            F32 focusLagLerp = LLSmoothInterpolation::getInterpolant( mFocusLag );
+            focus_pt_agent = lerp( focus_pt_agent, whereFocusWantsToBe, focusLagLerp );
+            mSimulatedFocusGlobal = gAgent.getPosGlobalFromAgent(focus_pt_agent);
+        }
+        mRelativeFocus = lerp(mRelativeFocus, (focus_pt_agent - mSubjectPosition) * ~mSubjectRotation, LLSmoothInterpolation::getInterpolant(0.05f));
+    }// if focus is not locked ---------------------------------------------
+
+
+    LLVector3 whereCameraPositionWantsToBe = gAgent.getPosAgentFromGlobal(mSimulatedPositionGlobal);
+    if (  mPositionLocked )
+    {
+        mRelativePos = (whereCameraPositionWantsToBe - mSubjectPosition) * ~mSubjectRotation;
+    }
+    else
+    {
+        //####################################################################################
+        // update Position
+        //####################################################################################
+        //-------------------------------------------------------------------------
+        // I determine the horizontal vector from the camera to the subject
+        //-------------------------------------------------------------------------
+        LLVector3 horizontalVectorFromCameraToSubject = vectorFromCameraToSubject;
+        horizontalVectorFromCameraToSubject.mV[VZ] = 0.0f;
+
+        //---------------------------------------------------------
+        // Now I determine the horizontal distance
+        //---------------------------------------------------------
+        F32 horizontalDistanceFromCameraToSubject = horizontalVectorFromCameraToSubject.magVec();
+
+        //---------------------------------------------------------
+        // Then I get the (normalized) horizontal direction...
+        //---------------------------------------------------------
+        LLVector3 horizontalDirectionFromCameraToSubject;
+        if ( horizontalDistanceFromCameraToSubject < DISTANCE_EPSILON )
+        {
+            // make sure we still have a normalized vector if distance is really small
+            // (this case is rare and fleeting)
+            horizontalDirectionFromCameraToSubject = LLVector3::z_axis;
+        }
+        else
+        {
+            // I'm not using the "normalize" method, because I can just divide by horizontalDistanceFromCameraToSubject
+            horizontalDirectionFromCameraToSubject = horizontalVectorFromCameraToSubject / horizontalDistanceFromCameraToSubject;
+        }
+
+        //------------------------------------------------------------------------------------------------------------
+        // Here is where I determine an offset relative to subject position in oder to set the ideal position.
+        //------------------------------------------------------------------------------------------------------------
+        if ( mPitchSineAndCosineNeedToBeUpdated )
+        {
+            calculatePitchSineAndCosine();
+            mPitchSineAndCosineNeedToBeUpdated = false;
+        }
+
+        LLVector3 positionOffsetFromSubject;
+        positionOffsetFromSubject.setVec
+            (
+                horizontalDirectionFromCameraToSubject.mV[ VX ] * mPitchCos,
+                horizontalDirectionFromCameraToSubject.mV[ VY ] * mPitchCos,
+                -mPitchSin
+            );
+
+        positionOffsetFromSubject *= mSimulatedDistance;
+
+        //----------------------------------------------------------------------
+        // Finally, ideal position is set by taking the subject position and
+        // extending the positionOffsetFromSubject from that
+        //----------------------------------------------------------------------
+        LLVector3 idealCameraPosition = offsetSubjectPosition - positionOffsetFromSubject;
+
+        //--------------------------------------------------------------------------------
+        // Now I prepare to move the current camera position towards its ideal position...
+        //--------------------------------------------------------------------------------
+        LLVector3 vectorFromPositionToIdealPosition = idealCameraPosition - simulated_pos_agent;
+        F32 distanceFromPositionToIdealPosition = vectorFromPositionToIdealPosition.magVec();
+
+        //put this inside of the block?
+        LLVector3 normalFromPositionToIdealPosition = vectorFromPositionToIdealPosition / distanceFromPositionToIdealPosition;
+
+        whereCameraPositionWantsToBe = simulated_pos_agent +
+            (normalFromPositionToIdealPosition * (distanceFromPositionToIdealPosition - mPositionThreshold));
+        //-------------------------------------------------------------------------------------------------
+        // The following method takes the target camera position and resets it so that it stays "behind" the subject,
+        // using behindness angle and behindness force as parameters affecting the exact behavior
+        //-------------------------------------------------------------------------------------------------
+        if ( distanceFromPositionToIdealPosition > mPositionThreshold )
+        {
+            F32 positionPullLerp = LLSmoothInterpolation::getInterpolant( mPositionLag );
+            simulated_pos_agent = lerp( simulated_pos_agent, whereCameraPositionWantsToBe, positionPullLerp );
+        }
+
+        //--------------------------------------------------------------------
+        // don't let the camera get farther than its official max distance
+        //--------------------------------------------------------------------
+        if ( distanceFromCameraToSubject > mMaxCameraDistantFromSubject )
+        {
+            LLVector3 directionFromCameraToSubject = vectorFromCameraToSubject / distanceFromCameraToSubject;
+            simulated_pos_agent = offsetSubjectPosition - directionFromCameraToSubject * mMaxCameraDistantFromSubject;
+        }
+
+        ////-------------------------------------------------------------------------------------------------
+        //// The following method takes mSimulatedPositionGlobal and resets it so that it stays "behind" the subject,
+        //// using behindness angle and behindness force as parameters affecting the exact behavior
+        ////-------------------------------------------------------------------------------------------------
+        updateBehindnessConstraint(gAgent.getPosAgentFromGlobal(mSimulatedFocusGlobal), simulated_pos_agent);
+        mSimulatedPositionGlobal = gAgent.getPosGlobalFromAgent(simulated_pos_agent);
+
+        mRelativePos = lerp(mRelativePos, (simulated_pos_agent - mSubjectPosition) * ~mSubjectRotation, LLSmoothInterpolation::getInterpolant(0.05f));
+    } // if position is not locked -----------------------------------------------------------
+
+
+    //####################################################################################
+    // update UpVector
+    //####################################################################################
+    // this just points upward for now, but I anticipate future effects requiring
+    // some rolling ("banking" effects for fun, swoopy vehicles, etc.)
+    mUpVector = LLVector3::z_axis;
 }
 
 
@@ -445,209 +445,209 @@ void LLFollowCam::update()
 //-------------------------------------------------------------------------------------
 bool LLFollowCam::updateBehindnessConstraint(LLVector3 focus, LLVector3& cam_position)
 {
-	bool constraint_active = false;
-	// only apply this stuff if the behindness angle is something other than opened up all the way
-	if ( mBehindnessMaxAngle < FOLLOW_CAM_MAX_BEHINDNESS_ANGLE - FOLLOW_CAM_BEHINDNESS_EPSILON )
-	{
-		//--------------------------------------------------------------
-		// horizontalized vector from focus to camera 
-		//--------------------------------------------------------------
-		LLVector3 horizontalVectorFromFocusToCamera;
-		horizontalVectorFromFocusToCamera.setVec(cam_position - focus);
-		horizontalVectorFromFocusToCamera.mV[ VZ ] = 0.0f; 
-		F32 cameraZ = cam_position.mV[ VZ ];
-
-		//--------------------------------------------------------------
-		// distance of horizontalized vector
-		//--------------------------------------------------------------
-		F32 horizontalDistance = horizontalVectorFromFocusToCamera.magVec();
-
-		//--------------------------------------------------------------------------------------------------
-		// calculate horizontalized back vector of the subject and scale by horizontalDistance
-		//--------------------------------------------------------------------------------------------------
-		LLVector3 horizontalSubjectBack( -1.0f, 0.0f, 0.0f );
-		horizontalSubjectBack *= mSubjectRotation;
-		horizontalSubjectBack.mV[ VZ ] = 0.0f; 
-		horizontalSubjectBack.normVec(); // because horizontalizing might make it shorter than 1
-		horizontalSubjectBack *= horizontalDistance;
-
-		//--------------------------------------------------------------------------------------------------
-		// find the angle (in degrees) between these vectors
-		//--------------------------------------------------------------------------------------------------
-		F32 cameraOffsetAngle = 0.f;
-		LLVector3 cameraOffsetRotationAxis;
-		LLQuaternion camera_offset_rotation;
-		camera_offset_rotation.shortestArc(horizontalSubjectBack, horizontalVectorFromFocusToCamera);
-		camera_offset_rotation.getAngleAxis(&cameraOffsetAngle, cameraOffsetRotationAxis);
-		cameraOffsetAngle *= RAD_TO_DEG;
-
-		if ( cameraOffsetAngle > mBehindnessMaxAngle )
-		{
-			F32 fraction = ((cameraOffsetAngle - mBehindnessMaxAngle) / cameraOffsetAngle) * LLSmoothInterpolation::getInterpolant(mBehindnessLag);
-			cam_position = focus + horizontalSubjectBack * (slerp(fraction, camera_offset_rotation, LLQuaternion::DEFAULT));
-			cam_position.mV[VZ] = cameraZ; // clamp z value back to what it was before we started messing with it
-			constraint_active = true;
-		}
-	}
-	return constraint_active;
+    bool constraint_active = false;
+    // only apply this stuff if the behindness angle is something other than opened up all the way
+    if ( mBehindnessMaxAngle < FOLLOW_CAM_MAX_BEHINDNESS_ANGLE - FOLLOW_CAM_BEHINDNESS_EPSILON )
+    {
+        //--------------------------------------------------------------
+        // horizontalized vector from focus to camera
+        //--------------------------------------------------------------
+        LLVector3 horizontalVectorFromFocusToCamera;
+        horizontalVectorFromFocusToCamera.setVec(cam_position - focus);
+        horizontalVectorFromFocusToCamera.mV[ VZ ] = 0.0f;
+        F32 cameraZ = cam_position.mV[ VZ ];
+
+        //--------------------------------------------------------------
+        // distance of horizontalized vector
+        //--------------------------------------------------------------
+        F32 horizontalDistance = horizontalVectorFromFocusToCamera.magVec();
+
+        //--------------------------------------------------------------------------------------------------
+        // calculate horizontalized back vector of the subject and scale by horizontalDistance
+        //--------------------------------------------------------------------------------------------------
+        LLVector3 horizontalSubjectBack( -1.0f, 0.0f, 0.0f );
+        horizontalSubjectBack *= mSubjectRotation;
+        horizontalSubjectBack.mV[ VZ ] = 0.0f;
+        horizontalSubjectBack.normVec(); // because horizontalizing might make it shorter than 1
+        horizontalSubjectBack *= horizontalDistance;
+
+        //--------------------------------------------------------------------------------------------------
+        // find the angle (in degrees) between these vectors
+        //--------------------------------------------------------------------------------------------------
+        F32 cameraOffsetAngle = 0.f;
+        LLVector3 cameraOffsetRotationAxis;
+        LLQuaternion camera_offset_rotation;
+        camera_offset_rotation.shortestArc(horizontalSubjectBack, horizontalVectorFromFocusToCamera);
+        camera_offset_rotation.getAngleAxis(&cameraOffsetAngle, cameraOffsetRotationAxis);
+        cameraOffsetAngle *= RAD_TO_DEG;
+
+        if ( cameraOffsetAngle > mBehindnessMaxAngle )
+        {
+            F32 fraction = ((cameraOffsetAngle - mBehindnessMaxAngle) / cameraOffsetAngle) * LLSmoothInterpolation::getInterpolant(mBehindnessLag);
+            cam_position = focus + horizontalSubjectBack * (slerp(fraction, camera_offset_rotation, LLQuaternion::DEFAULT));
+            cam_position.mV[VZ] = cameraZ; // clamp z value back to what it was before we started messing with it
+            constraint_active = true;
+        }
+    }
+    return constraint_active;
 }
 
 
 //---------------------------------------------------------
 void LLFollowCam::calculatePitchSineAndCosine()
 {
-	F32 radian = mPitch * DEG_TO_RAD;
-	mPitchCos = cos( radian );
-	mPitchSin = sin( radian );
+    F32 radian = mPitch * DEG_TO_RAD;
+    mPitchCos = cos( radian );
+    mPitchSin = sin( radian );
 }
 
 //---------------------------------------------------------
 void LLFollowCam::setSubjectPositionAndRotation( const LLVector3 p, const LLQuaternion r )
 {
-	mSubjectPosition = p;
-	mSubjectRotation = r;
+    mSubjectPosition = p;
+    mSubjectRotation = r;
 }
 
 
 //---------------------------------------------------------
-void LLFollowCam::zoom( S32 z ) 
-{ 
-	F32 zoomAmount = z * mSimulatedDistance * FOLLOW_CAM_ZOOM_FACTOR;
-
-	if (( zoomAmount <  FOLLOW_CAM_MIN_ZOOM_AMOUNT )
-	&&  ( zoomAmount > -FOLLOW_CAM_MIN_ZOOM_AMOUNT ))
-	{
-		if ( zoomAmount < 0.0f )
-		{
-			zoomAmount = -FOLLOW_CAM_MIN_ZOOM_AMOUNT;
-		}
-		else
-		{
-			zoomAmount = FOLLOW_CAM_MIN_ZOOM_AMOUNT;
-		}
-	}
-
-	mSimulatedDistance += zoomAmount;
-
-	mZoomedToMinimumDistance = false;
-	if ( mSimulatedDistance < FOLLOW_CAM_MIN_DISTANCE ) 
-	{
-		mSimulatedDistance = FOLLOW_CAM_MIN_DISTANCE;
-
-		// if zoomAmount is negative (i.e., getting closer), then
-		// this signifies having hit the minimum:
-		if ( zoomAmount < 0.0f )
-		{
-			mZoomedToMinimumDistance = true;
-		}
-	}
-	else if ( mSimulatedDistance > mMaxCameraDistantFromSubject ) 
-	{
-		mSimulatedDistance = mMaxCameraDistantFromSubject;
-	}
+void LLFollowCam::zoom( S32 z )
+{
+    F32 zoomAmount = z * mSimulatedDistance * FOLLOW_CAM_ZOOM_FACTOR;
+
+    if (( zoomAmount <  FOLLOW_CAM_MIN_ZOOM_AMOUNT )
+    &&  ( zoomAmount > -FOLLOW_CAM_MIN_ZOOM_AMOUNT ))
+    {
+        if ( zoomAmount < 0.0f )
+        {
+            zoomAmount = -FOLLOW_CAM_MIN_ZOOM_AMOUNT;
+        }
+        else
+        {
+            zoomAmount = FOLLOW_CAM_MIN_ZOOM_AMOUNT;
+        }
+    }
+
+    mSimulatedDistance += zoomAmount;
+
+    mZoomedToMinimumDistance = false;
+    if ( mSimulatedDistance < FOLLOW_CAM_MIN_DISTANCE )
+    {
+        mSimulatedDistance = FOLLOW_CAM_MIN_DISTANCE;
+
+        // if zoomAmount is negative (i.e., getting closer), then
+        // this signifies having hit the minimum:
+        if ( zoomAmount < 0.0f )
+        {
+            mZoomedToMinimumDistance = true;
+        }
+    }
+    else if ( mSimulatedDistance > mMaxCameraDistantFromSubject )
+    {
+        mSimulatedDistance = mMaxCameraDistantFromSubject;
+    }
 }
 
 
 //---------------------------------------------------------
 bool LLFollowCam::isZoomedToMinimumDistance()
 {
-	return mZoomedToMinimumDistance;
+    return mZoomedToMinimumDistance;
 }
 
 
 //---------------------------------------------------------
 void LLFollowCam::reset( const LLVector3 p, const LLVector3 f , const LLVector3 u )
 {
-	setPosition(p);
-	setFocus(f);
-	mUpVector	= u;
+    setPosition(p);
+    setFocus(f);
+    mUpVector   = u;
 }
 
 //---------------------------------------------------------
 void LLFollowCam::setMaxCameraDistantFromSubject( F32 m )
 {
-	mMaxCameraDistantFromSubject = m;
+    mMaxCameraDistantFromSubject = m;
 }
 
 
-void LLFollowCam::setPitch( F32 p ) 
-{ 
-	LLFollowCamParams::setPitch(p);
-	mPitchSineAndCosineNeedToBeUpdated = true; // important
+void LLFollowCam::setPitch( F32 p )
+{
+    LLFollowCamParams::setPitch(p);
+    mPitchSineAndCosineNeedToBeUpdated = true; // important
 }
 
-void LLFollowCam::setDistance( F32 d ) 
-{ 
-	if (d != mDistance)
-	{
-		LLFollowCamParams::setDistance(d);
-		mSimulatedDistance = d;
-		mZoomedToMinimumDistance = false; 
-	}
+void LLFollowCam::setDistance( F32 d )
+{
+    if (d != mDistance)
+    {
+        LLFollowCamParams::setDistance(d);
+        mSimulatedDistance = d;
+        mZoomedToMinimumDistance = false;
+    }
 }
 
-void LLFollowCam::setPosition( const LLVector3& p ) 
-{ 
-	if (p != mPosition)
-	{
-		LLFollowCamParams::setPosition(p);
-		mSimulatedPositionGlobal = gAgent.getPosGlobalFromAgent(mPosition);
-		if (mPositionLocked)
-		{
-			mRelativePos = (mPosition - mSubjectPosition) * ~mSubjectRotation;
-		}
-	}
+void LLFollowCam::setPosition( const LLVector3& p )
+{
+    if (p != mPosition)
+    {
+        LLFollowCamParams::setPosition(p);
+        mSimulatedPositionGlobal = gAgent.getPosGlobalFromAgent(mPosition);
+        if (mPositionLocked)
+        {
+            mRelativePos = (mPosition - mSubjectPosition) * ~mSubjectRotation;
+        }
+    }
 }
 
-void LLFollowCam::setFocus( const LLVector3& f ) 
-{ 
-	if (f != mFocus)
-	{
-		LLFollowCamParams::setFocus(f);
-		mSimulatedFocusGlobal = gAgent.getPosGlobalFromAgent(f);
-		if (mFocusLocked)
-		{
-			mRelativeFocus = (mFocus - mSubjectPosition) * ~mSubjectRotation;
-		}
-	}
+void LLFollowCam::setFocus( const LLVector3& f )
+{
+    if (f != mFocus)
+    {
+        LLFollowCamParams::setFocus(f);
+        mSimulatedFocusGlobal = gAgent.getPosGlobalFromAgent(f);
+        if (mFocusLocked)
+        {
+            mRelativeFocus = (mFocus - mSubjectPosition) * ~mSubjectRotation;
+        }
+    }
 }
 
 void LLFollowCam::setPositionLocked( bool locked )
 {
-	LLFollowCamParams::setPositionLocked(locked);
-	if (locked)
-	{
-		// propagate set position to relative position
-		mRelativePos = (gAgent.getPosAgentFromGlobal(mSimulatedPositionGlobal) - mSubjectPosition) * ~mSubjectRotation;
-	}
+    LLFollowCamParams::setPositionLocked(locked);
+    if (locked)
+    {
+        // propagate set position to relative position
+        mRelativePos = (gAgent.getPosAgentFromGlobal(mSimulatedPositionGlobal) - mSubjectPosition) * ~mSubjectRotation;
+    }
 }
 
 void LLFollowCam::setFocusLocked( bool locked )
 {
-	LLFollowCamParams::setFocusLocked(locked);
-	if (locked)	
-	{
-		// propagate set position to relative position
-		mRelativeFocus = (gAgent.getPosAgentFromGlobal(mSimulatedFocusGlobal) - mSubjectPosition) * ~mSubjectRotation;
-	}
+    LLFollowCamParams::setFocusLocked(locked);
+    if (locked)
+    {
+        // propagate set position to relative position
+        mRelativeFocus = (gAgent.getPosAgentFromGlobal(mSimulatedFocusGlobal) - mSubjectPosition) * ~mSubjectRotation;
+    }
 }
 
 
-LLVector3	LLFollowCam::getSimulatedPosition() const 
-{ 
-	// return simulated position
-	return mSubjectPosition + (mRelativePos * mSubjectRotation);
+LLVector3   LLFollowCam::getSimulatedPosition() const
+{
+    // return simulated position
+    return mSubjectPosition + (mRelativePos * mSubjectRotation);
 }
 
-LLVector3	LLFollowCam::getSimulatedFocus() const 
-{ 
-	// return simulated focus point
-	return mSubjectPosition + (mRelativeFocus * mSubjectRotation);
+LLVector3   LLFollowCam::getSimulatedFocus() const
+{
+    // return simulated focus point
+    return mSubjectPosition + (mRelativeFocus * mSubjectRotation);
 }
 
-LLVector3	LLFollowCam::getUpVector() 
-{ 
-	return mUpVector;			
+LLVector3   LLFollowCam::getUpVector()
+{
+    return mUpVector;
 }
 
 
@@ -678,201 +678,201 @@ LLFollowCamMgr::~LLFollowCamMgr()
 
 void LLFollowCamMgr::setPositionLag( const LLUUID& source, F32 lag)
 {
-	LLFollowCamParams* paramsp = getParamsForID(source);
-	if (paramsp)
-	{
-		paramsp->setPositionLag(lag);
-	}
+    LLFollowCamParams* paramsp = getParamsForID(source);
+    if (paramsp)
+    {
+        paramsp->setPositionLag(lag);
+    }
 }
 
 void LLFollowCamMgr::setFocusLag( const LLUUID& source, F32 lag)
 {
-	LLFollowCamParams* paramsp = getParamsForID(source);
-	if (paramsp)
-	{
-		paramsp->setFocusLag(lag);
-	}
+    LLFollowCamParams* paramsp = getParamsForID(source);
+    if (paramsp)
+    {
+        paramsp->setFocusLag(lag);
+    }
 }
 
 void LLFollowCamMgr::setFocusThreshold( const LLUUID& source, F32 threshold)
 {
-	LLFollowCamParams* paramsp = getParamsForID(source);
-	if (paramsp)
-	{
-		paramsp->setFocusThreshold(threshold);
-	}
+    LLFollowCamParams* paramsp = getParamsForID(source);
+    if (paramsp)
+    {
+        paramsp->setFocusThreshold(threshold);
+    }
 
 }
 
 void LLFollowCamMgr::setPositionThreshold( const LLUUID& source, F32 threshold)
 {
-	LLFollowCamParams* paramsp = getParamsForID(source);
-	if (paramsp)
-	{
-		paramsp->setPositionThreshold(threshold);
-	}
+    LLFollowCamParams* paramsp = getParamsForID(source);
+    if (paramsp)
+    {
+        paramsp->setPositionThreshold(threshold);
+    }
 }
 
 void LLFollowCamMgr::setDistance( const LLUUID& source, F32 distance)
 {
-	LLFollowCamParams* paramsp = getParamsForID(source);
-	if (paramsp)
-	{
-		paramsp->setDistance(distance);
-	}
+    LLFollowCamParams* paramsp = getParamsForID(source);
+    if (paramsp)
+    {
+        paramsp->setDistance(distance);
+    }
 }
 
 void LLFollowCamMgr::setPitch( const LLUUID& source, F32 pitch)
 {
-	LLFollowCamParams* paramsp = getParamsForID(source);
-	if (paramsp)
-	{
-		paramsp->setPitch(pitch);
-	}
+    LLFollowCamParams* paramsp = getParamsForID(source);
+    if (paramsp)
+    {
+        paramsp->setPitch(pitch);
+    }
 }
 
 void LLFollowCamMgr::setFocusOffset( const LLUUID& source, const LLVector3& offset)
 {
-	LLFollowCamParams* paramsp = getParamsForID(source);
-	if (paramsp)
-	{
-		paramsp->setFocusOffset(offset);
-	}
+    LLFollowCamParams* paramsp = getParamsForID(source);
+    if (paramsp)
+    {
+        paramsp->setFocusOffset(offset);
+    }
 }
 
 void LLFollowCamMgr::setBehindnessAngle( const LLUUID& source, F32 angle)
 {
-	LLFollowCamParams* paramsp = getParamsForID(source);
-	if (paramsp)
-	{
-		paramsp->setBehindnessAngle(angle);
-	}
+    LLFollowCamParams* paramsp = getParamsForID(source);
+    if (paramsp)
+    {
+        paramsp->setBehindnessAngle(angle);
+    }
 }
 
 void LLFollowCamMgr::setBehindnessLag( const LLUUID& source, F32 force)
 {
-	LLFollowCamParams* paramsp = getParamsForID(source);
-	if (paramsp)
-	{
-		paramsp->setBehindnessLag(force);
-	}
+    LLFollowCamParams* paramsp = getParamsForID(source);
+    if (paramsp)
+    {
+        paramsp->setBehindnessLag(force);
+    }
 }
 
 void LLFollowCamMgr::setPosition( const LLUUID& source, const LLVector3 position)
 {
-	LLFollowCamParams* paramsp = getParamsForID(source);
-	if (paramsp)
-	{
-		paramsp->setPosition(position);
-	}
+    LLFollowCamParams* paramsp = getParamsForID(source);
+    if (paramsp)
+    {
+        paramsp->setPosition(position);
+    }
 }
 
 void LLFollowCamMgr::setFocus( const LLUUID& source, const LLVector3 focus)
 {
-	LLFollowCamParams* paramsp = getParamsForID(source);
-	if (paramsp)
-	{
-		paramsp->setFocus(focus);
-	}
+    LLFollowCamParams* paramsp = getParamsForID(source);
+    if (paramsp)
+    {
+        paramsp->setFocus(focus);
+    }
 }
 
 void LLFollowCamMgr::setPositionLocked( const LLUUID& source, bool locked)
 {
-	LLFollowCamParams* paramsp = getParamsForID(source);
-	if (paramsp)
-	{
-		paramsp->setPositionLocked(locked);
-	}
+    LLFollowCamParams* paramsp = getParamsForID(source);
+    if (paramsp)
+    {
+        paramsp->setPositionLocked(locked);
+    }
 }
 
 void LLFollowCamMgr::setFocusLocked( const LLUUID& source, bool locked )
 {
-	LLFollowCamParams* paramsp = getParamsForID(source);
-	if (paramsp)
-	{
-		paramsp->setFocusLocked(locked);
-	}
+    LLFollowCamParams* paramsp = getParamsForID(source);
+    if (paramsp)
+    {
+        paramsp->setFocusLocked(locked);
+    }
 }
 
 LLFollowCamParams* LLFollowCamMgr::getParamsForID(const LLUUID& source)
 {
-	LLFollowCamParams* params = NULL;
+    LLFollowCamParams* params = NULL;
 
-	param_map_t::iterator found_it = mParamMap.find(source);
-	if (found_it == mParamMap.end()) // didn't find it?
-	{
-		params = new LLFollowCamParams();
-		mParamMap[source] = params;
-	}
-	else
-	{
-		params = found_it->second;
-	}
+    param_map_t::iterator found_it = mParamMap.find(source);
+    if (found_it == mParamMap.end()) // didn't find it?
+    {
+        params = new LLFollowCamParams();
+        mParamMap[source] = params;
+    }
+    else
+    {
+        params = found_it->second;
+    }
 
-	return params;
+    return params;
 }
 
 LLFollowCamParams* LLFollowCamMgr::getActiveFollowCamParams()
 {
-	if (mParamStack.empty())
-	{
-		return NULL;
-	}
+    if (mParamStack.empty())
+    {
+        return NULL;
+    }
 
-	return mParamStack.back();
+    return mParamStack.back();
 }
 
 void LLFollowCamMgr::setCameraActive( const LLUUID& source, bool active )
 {
-	LLFollowCamParams* params = getParamsForID(source);
-	param_stack_t::iterator found_it = std::find(mParamStack.begin(), mParamStack.end(), params);
-	if (found_it != mParamStack.end())
-	{
-		mParamStack.erase(found_it);
-	}
-	// put on top of stack
-	if(active)
-	{
-		mParamStack.push_back(params);
-	}
+    LLFollowCamParams* params = getParamsForID(source);
+    param_stack_t::iterator found_it = std::find(mParamStack.begin(), mParamStack.end(), params);
+    if (found_it != mParamStack.end())
+    {
+        mParamStack.erase(found_it);
+    }
+    // put on top of stack
+    if(active)
+    {
+        mParamStack.push_back(params);
+    }
 }
 
 void LLFollowCamMgr::removeFollowCamParams(const LLUUID& source)
 {
-	setCameraActive(source, false);
-	LLFollowCamParams* params = getParamsForID(source);
-	mParamMap.erase(source);
-	delete params;
+    setCameraActive(source, false);
+    LLFollowCamParams* params = getParamsForID(source);
+    mParamMap.erase(source);
+    delete params;
 }
 
 bool LLFollowCamMgr::isScriptedCameraSource(const LLUUID& source)
 {
-	param_map_t::iterator found_it = mParamMap.find(source);
-	return (found_it != mParamMap.end());
+    param_map_t::iterator found_it = mParamMap.find(source);
+    return (found_it != mParamMap.end());
 }
 
 void LLFollowCamMgr::dump()
 {
-	S32 param_count = 0;
-	LL_INFOS() << "Scripted camera active stack" << LL_ENDL;
-	for (param_stack_t::iterator param_it = mParamStack.begin();
-		param_it != mParamStack.end();
-		++param_it)
-	{
-		LL_INFOS() << param_count++ << 
-			" rot_limit: " << (*param_it)->getBehindnessAngle() << 
-			" rot_lag: " << (*param_it)->getBehindnessLag() << 
-			" distance: " << (*param_it)->getDistance() << 
-			" focus: " << (*param_it)->getFocus() << 
-			" foc_lag: " << (*param_it)->getFocusLag() << 
-			" foc_lock: " << ((*param_it)->getFocusLocked() ? "Y" : "N") << 
-			" foc_offset: " << (*param_it)->getFocusOffset() << 
-			" foc_thresh: " << (*param_it)->getFocusThreshold() << 
-			" pitch: " << (*param_it)->getPitch() << 
-			" pos: " << (*param_it)->getPosition() << 
-			" pos_lag: " << (*param_it)->getPositionLag() << 
-			" pos_lock: " << ((*param_it)->getPositionLocked() ? "Y" : "N") << 
-			" pos_thresh: " << (*param_it)->getPositionThreshold() << LL_ENDL;
-	}
+    S32 param_count = 0;
+    LL_INFOS() << "Scripted camera active stack" << LL_ENDL;
+    for (param_stack_t::iterator param_it = mParamStack.begin();
+        param_it != mParamStack.end();
+        ++param_it)
+    {
+        LL_INFOS() << param_count++ <<
+            " rot_limit: " << (*param_it)->getBehindnessAngle() <<
+            " rot_lag: " << (*param_it)->getBehindnessLag() <<
+            " distance: " << (*param_it)->getDistance() <<
+            " focus: " << (*param_it)->getFocus() <<
+            " foc_lag: " << (*param_it)->getFocusLag() <<
+            " foc_lock: " << ((*param_it)->getFocusLocked() ? "Y" : "N") <<
+            " foc_offset: " << (*param_it)->getFocusOffset() <<
+            " foc_thresh: " << (*param_it)->getFocusThreshold() <<
+            " pitch: " << (*param_it)->getPitch() <<
+            " pos: " << (*param_it)->getPosition() <<
+            " pos_lag: " << (*param_it)->getPositionLag() <<
+            " pos_lock: " << ((*param_it)->getPositionLocked() ? "Y" : "N") <<
+            " pos_thresh: " << (*param_it)->getPositionThreshold() << LL_ENDL;
+    }
 }