path: root/indra/newview/llfollowcam.cpp

/**
 * @file llfollowcam.cpp
 * @author Jeffrey Ventrella
 * @brief LLFollowCam class implementation
 *
 * $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$
 */

#include "llviewerprecompiledheaders.h"
#include "llfollowcam.h"
#include "llagent.h"

//-------------------------------------------------------
// 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

//----------------------------------------------------------------------------------------
// 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;

//----------------------------------------------------------------------------------------
// 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;

//----------------------------------------------------------------------------------------
// 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;

//----------------------------------------------------------------------------------------
// 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;

//----------------------------------------------------------------------------------------
// 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

//----------------------------------------------------------------------------------------
// this is an angluar value
// 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!


//----------------------------------------------------------------------------------------
// 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;

//----------------------------------------------------------------------------------------
// 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;

//---------------------------------------------------------------------------------------------------------------------
// 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;

//------------------------------------
// 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        );

}

LLFollowCamParams::~LLFollowCamParams() { }

//---------------------------------------------------------
// buncho set methods
//---------------------------------------------------------

//---------------------------------------------------------
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::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::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::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::setPositionLocked( bool l )
{
    mPositionLocked = l;
}

//---------------------------------------------------------
void LLFollowCamParams::setFocusLocked( bool 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::setPosition( const LLVector3& p )
{
    mUsePosition = true;
    mPosition = p;
}

//---------------------------------------------------------
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;         }

//------------------------------------
// Constructor
//------------------------------------
LLFollowCam::LLFollowCam() : LLFollowCamParams()
{
    mUpVector                           = LLVector3::z_axis;
    mSubjectPosition                    = LLVector3::zero;
    mSubjectRotation                    = LLQuaternion::DEFAULT;

    mZoomedToMinimumDistance            = false;
    mPitchCos = mPitchSin = 0.f;
    mPitchSineAndCosineNeedToBeUpdated  = true;

    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());
    }
}

//---------------------------------------------------------------------------------------------------------
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;
}



//-------------------------------------------------------------------------------------
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;
}


//---------------------------------------------------------
void LLFollowCam::calculatePitchSineAndCosine()
{
    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;
}


//---------------------------------------------------------
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;
}


//---------------------------------------------------------
void LLFollowCam::reset( const LLVector3 p, const LLVector3 f , const LLVector3 u )
{
    setPosition(p);
    setFocus(f);
    mUpVector   = u;
}

//---------------------------------------------------------
void LLFollowCam::setMaxCameraDistantFromSubject( F32 m )
{
    mMaxCameraDistantFromSubject = m;
}


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::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::setPositionLocked( bool locked )
{
    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;
    }
}


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::getUpVector()
{
    return mUpVector;
}


//------------------------------------
// Destructor
//------------------------------------
LLFollowCam::~LLFollowCam()
{
}


//-------------------------------------------------------
// LLFollowCamMgr
//-------------------------------------------------------
LLFollowCamMgr::LLFollowCamMgr()
{
}

LLFollowCamMgr::~LLFollowCamMgr()
{
    for (param_map_t::iterator iter = mParamMap.begin(); iter != mParamMap.end(); ++iter)
    {
        LLFollowCamParams* params = iter->second;
        delete params;
    }
    mParamMap.clear();
}

void LLFollowCamMgr::setPositionLag( const LLUUID& source, F32 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);
    }
}

void LLFollowCamMgr::setFocusThreshold( const LLUUID& source, F32 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);
    }
}

void LLFollowCamMgr::setDistance( const LLUUID& source, F32 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);
    }
}

void LLFollowCamMgr::setFocusOffset( const LLUUID& source, const LLVector3& 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);
    }
}

void LLFollowCamMgr::setBehindnessLag( const LLUUID& source, F32 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);
    }
}

void LLFollowCamMgr::setFocus( const LLUUID& source, const LLVector3 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);
    }
}

void LLFollowCamMgr::setFocusLocked( const LLUUID& source, bool locked )
{
    LLFollowCamParams* paramsp = getParamsForID(source);
    if (paramsp)
    {
        paramsp->setFocusLocked(locked);
    }
}

LLFollowCamParams* LLFollowCamMgr::getParamsForID(const LLUUID& source)
{
    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;
    }

    return params;
}

LLFollowCamParams* LLFollowCamMgr::getActiveFollowCamParams()
{
    if (mParamStack.empty())
    {
        return NULL;
    }

    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);
    }
}

void LLFollowCamMgr::removeFollowCamParams(const LLUUID& source)
{
    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());
}

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;
    }
}