AutoCamera.h

#pragma once
#include "BaseCamera.h"

namespace ParaEngine
{
    class CBipedObject;
class CAutoCamera : public CFirstPersonCamera
{
public:
    CAutoCamera(void);
    ~CAutoCamera(void);

    enum CameraConstraintEnum
    {
        CameraConstraintFocus,
        CameraConstraintNone
    };

    
    struct CameraConstraint
    {
    protected:
        CameraConstraintEnum m_typeConstraint;
    public:
        void SetConstraintType(CameraConstraintEnum typeC){m_typeConstraint = typeC;};
        CameraConstraintEnum GetConstraintType(){return m_typeConstraint;};
        
        Vector3 m_vMinLookAt;
        Vector3 m_vMaxLookAt;

        Vector3 m_vMinEye;
        Vector3 m_vMaxEye;
    public:
        void ConstrainToBoundary( Vector3* pV, const Vector3* pvMin, const Vector3* pvMax );
        void ConstrainToOuterBoundary( Vector3* pV, const Vector3* pvMin, const Vector3* pvMax );

        void UpdateFocusConstraint(const Vector3* pV, 
                    FLOAT fLookAtRadius, FLOAT fLookAtMinHeight,FLOAT fLookAtMaxHeight,
                    FLOAT fEyeRadius, FLOAT fEyeMinHeight,FLOAT fEyeMaxHeight);
        void BoundToFocusConstraint(Vector3* pEye, Vector3* pLookAt);
        
        CameraConstraint()
        {
            m_typeConstraint = CameraConstraintNone;
        };
    };
    
public:
    // implementation of IAttributeFields

    virtual int GetAttributeClassID(){return ATTRIBUTE_CLASSID_CAutoCamera;}
    virtual const char* GetAttributeClassName(){static const char name[] = "CAutoCamera"; return name;}
    virtual const char* GetAttributeClassDescription(){static const char desc[] = ""; return desc;}
    virtual int InstallFields(CAttributeClass* pClass, bool bOverride);

    
    ATTRIBUTE_METHOD1(CAutoCamera, IsAlwaysRun_s, bool*)    {*p1 = cls->IsAlwaysRun(); return S_OK;}
    ATTRIBUTE_METHOD1(CAutoCamera, SetAlwaysRun_s, bool)    {cls->SetAlwaysRun(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CAutoCamera, IsCamAlwaysBehindObject_s, bool*)    {*p1 = cls->IsCamAlwaysBehindObject(); return S_OK;}
    ATTRIBUTE_METHOD1(CAutoCamera, SetCamAlwaysBehindObject_s, bool)    {cls->SetCamAlwaysBehindObject(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CAutoCamera, IsUseRightButtonBipedFacing_s, bool*)    {*p1 = cls->IsUseRightButtonBipedFacing(); return S_OK;}
    ATTRIBUTE_METHOD1(CAutoCamera, SetUseRightButtonBipedFacing_s, bool)    {cls->SetUseRightButtonBipedFacing(p1); return S_OK;}
    

    ATTRIBUTE_METHOD(CAutoCamera, Reset_s)  {cls->Reset(); return S_OK;}
    ATTRIBUTE_METHOD(CAutoCamera, FreeCameraMode_s) {cls->FreeCameraMode(); return S_OK;}
    ATTRIBUTE_METHOD(CAutoCamera, FollowMode_s) {cls->FollowMode(); return S_OK;}
    ATTRIBUTE_METHOD1(CAutoCamera, GetCameraMode_s, int*)   {*p1 = (int)(cls->GetCameraMode()); return S_OK;}
    ATTRIBUTE_METHOD1(CAutoCamera, SetCameraMode_s, int)    {cls->SetCameraMode((CameraMode)p1); return S_OK;}

    ATTRIBUTE_METHOD1(CAutoCamera, GetKeyboardMovVelocity_s, float*)    {*p1 = cls->GetKeyboardMovVelocity(); return S_OK;}
    ATTRIBUTE_METHOD1(CAutoCamera, SetKeyboardMovVelocity_s, float) {cls->SetKeyboardMovVelocity(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CAutoCamera, GetKeyboardRotVelocity_s, float*)    {*p1 = cls->GetKeyboardRotVelocity(); return S_OK;}
    ATTRIBUTE_METHOD1(CAutoCamera, SetKeyboardRotVelocity_s, float) {cls->SetKeyboardRotVelocity(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CAutoCamera, GetCameraObjectDistance_s, double*)  { *p1 = cls->GetCameraObjectDistance(); return S_OK; }
    ATTRIBUTE_METHOD1(CAutoCamera, SetCameraObjectDistance_s, double)   { cls->SetCameraObjectDistance(p1); return S_OK; }

    ATTRIBUTE_METHOD1(CAutoCamera, GetCameraLiftupAngle_s, double*) { *p1 = cls->GetCameraLiftupAngle(); return S_OK; }
    ATTRIBUTE_METHOD1(CAutoCamera, SetCameraLiftupAngle_s, double)  { cls->SetCameraLiftupAngle(p1); return S_OK; }

    ATTRIBUTE_METHOD1(CAutoCamera, GetCameraRotX_s, double*)    { *p1 = cls->GetCameraRotX(); return S_OK; }
    ATTRIBUTE_METHOD1(CAutoCamera, SetCameraRotX_s, double) { cls->SetCameraRotX(p1); return S_OK; }

    ATTRIBUTE_METHOD1(CAutoCamera, GetCameraRotY_s, double*)    { *p1 = cls->GetCameraRotY(); return S_OK; }
    ATTRIBUTE_METHOD1(CAutoCamera, SetCameraRotY_s, double) { cls->SetCameraRotY(p1); return S_OK; }

    ATTRIBUTE_METHOD1(CAutoCamera, GetCameraRotZ_s, double*)    { *p1 = cls->GetCameraRotZ(); return S_OK; }
    ATTRIBUTE_METHOD1(CAutoCamera, SetCameraRotZ_s, double) { cls->SetCameraRotZ(p1); return S_OK; }

    ATTRIBUTE_METHOD1(CAutoCamera, GetLookAtShiftY_s, double*)  { *p1 = cls->GetLookAtShiftY(); return S_OK; }
    ATTRIBUTE_METHOD1(CAutoCamera, SetLookAtShiftY_s, double)   { cls->SetLookAtShiftY(p1); return S_OK; }

    ATTRIBUTE_METHOD1(CAutoCamera, GetEnableKeyboard_s, bool*)  {*p1 = cls->GetEnableKeyboard(); return S_OK;}
    ATTRIBUTE_METHOD1(CAutoCamera, EnableKeyboard_s, bool)  {cls->EnableKeyboard(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CAutoCamera, GetEnableMouseLeftButton_s, bool*)   {*p1 = cls->GetEnableMouseLeftButton(); return S_OK;}
    ATTRIBUTE_METHOD1(CAutoCamera, EnableMouseLeftButton_s, bool)   {cls->EnableMouseLeftButton(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CAutoCamera, GetEnableMouseRightButton_s, bool*)  {*p1 = cls->GetEnableMouseRightButton(); return S_OK;}
    ATTRIBUTE_METHOD1(CAutoCamera, EnableMouseRightButton_s, bool)  {cls->EnableMouseRightButton(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CAutoCamera, GetEnableMouseWheel_s, bool*)    {*p1 = cls->GetEnableMouseWheel(); return S_OK;}
    ATTRIBUTE_METHOD1(CAutoCamera, EnableMouseWheel_s, bool)    {cls->EnableMouseWheel(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CAutoCamera, GetPhysicsGroupMask_s, DWORD*)   {*p1 = cls->GetPhysicsGroupMask(); return S_OK;}
    ATTRIBUTE_METHOD1(CAutoCamera, SetPhysicsGroupMask_s, DWORD)    {cls->SetPhysicsGroupMask(p1); return S_OK;}
    
    ATTRIBUTE_METHOD1(CAutoCamera, IsEnableMouseRightDrag_s, bool*) {*p1 = cls->IsEnableMouseRightDrag(); return S_OK;}
    ATTRIBUTE_METHOD1(CAutoCamera, EnableMouseRightDrag_s, bool)    {cls->EnableMouseRightDrag(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CAutoCamera, IsEnableMouseLeftDrag_s, bool*)  {*p1 = cls->IsEnableMouseLeftDrag(); return S_OK;}
    ATTRIBUTE_METHOD1(CAutoCamera, EnableMouseLeftDrag_s, bool) {cls->EnableMouseLeftDrag(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CAutoCamera, IsLockMouseWhenDragging_s, bool*) { *p1 = cls->IsLockMouseWhenDragging(); return S_OK; }
    ATTRIBUTE_METHOD1(CAutoCamera, SetLockMouseWhenDragging_s, bool) { cls->SetLockMouseWhenDragging(p1); return S_OK; }

    ATTRIBUTE_METHOD1(CAutoCamera, IsUseCharacterLookup_s, bool*)   {*p1 = cls->IsUseCharacterLookup(); return S_OK;}
    ATTRIBUTE_METHOD1(CAutoCamera, SetUseCharacterLookup_s, bool)   {cls->SetUseCharacterLookup(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CAutoCamera, GetAlwaysRotateCameraWhenFPS_s, bool*)   {*p1 = cls->GetAlwaysRotateCameraWhenFPS(); return S_OK;}
    ATTRIBUTE_METHOD1(CAutoCamera, EnableAlwaysRotateCameraWhenFPS_s, bool) {cls->EnableAlwaysRotateCameraWhenFPS(p1); return S_OK;}


    ATTRIBUTE_METHOD1(CAutoCamera, IsUseCharacterLookupWhenMounted_s, bool*)    {*p1 = cls->IsUseCharacterLookupWhenMounted(); return S_OK;}
    ATTRIBUTE_METHOD1(CAutoCamera, SetUseCharacterLookupWhenMounted_s, bool)    {cls->SetUseCharacterLookupWhenMounted(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CAutoCamera, GetCharacterLookupBoneIndex_s, int*) {*p1 = cls->GetCharacterLookupBoneIndex(); return S_OK;}
    ATTRIBUTE_METHOD1(CAutoCamera, SetCharacterLookupBoneIndex_s, int)  {cls->SetCharacterLookupBoneIndex(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CAutoCamera, IsCameraMoved_s, bool*)  {*p1 = cls->IsCameraMoved(); return S_OK;}

    ATTRIBUTE_METHOD1(CAutoCamera, IsBlockInput_s, bool*)   {*p1 = cls->IsBlockInput(); return S_OK;}
    ATTRIBUTE_METHOD1(CAutoCamera, SetBlockInput_s, bool)   {cls->SetBlockInput(p1); return S_OK;}
    
    ATTRIBUTE_METHOD1(CAutoCamera, GetMaxCameraObjectDistance_s, double*)   {*p1 = cls->GetMaxCameraObjectDistance(); return S_OK;}
    ATTRIBUTE_METHOD1(CAutoCamera, SetMaxCameraObjectDistance_s, double)    { cls->SetMaxCameraObjectDistance(p1); return S_OK; }

    ATTRIBUTE_METHOD1(CAutoCamera, GetMinCameraObjectDistance_s, double*)   { *p1 = cls->GetMinCameraObjectDistance(); return S_OK; }
    ATTRIBUTE_METHOD1(CAutoCamera, SetMinCameraObjectDistance_s, double)    { cls->SetMinCameraObjectDistance(p1); return S_OK; }

    ATTRIBUTE_METHOD1(CAutoCamera, GetCameraRollbackSpeed_s, float*)    { *p1 = cls->GetCameraRollbackSpeed(); return S_OK; }
    ATTRIBUTE_METHOD1(CAutoCamera, SetCameraRollbackSpeed_s, float) { cls->SetCameraRollbackSpeed(p1); return S_OK; }

    ATTRIBUTE_METHOD1(CAutoCamera, GetCameraLookatOffset_s, Vector3*)   {*p1 = cls->GetCameraLookatOffset(); return S_OK;}
    ATTRIBUTE_METHOD1(CAutoCamera, SetCameraLookatOffset_s, Vector3)    {cls->SetCameraLookatOffset(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CAutoCamera, GetAdditionalCameraRotate_s, Vector3*)   { *p1 = cls->GetAdditionalCameraRotate(); return S_OK; }
    ATTRIBUTE_METHOD1(CAutoCamera, SetAdditionalCameraRotate_s, Vector3)    { cls->SetAdditionalCameraRotate(p1); return S_OK; }
    
    ATTRIBUTE_METHOD1(CAutoCamera, GetMaxYShiftSpeed_s, float*) {*p1 = cls->GetMaxYShiftSpeed(); return S_OK;}
    ATTRIBUTE_METHOD1(CAutoCamera, SetMaxYShiftSpeed_s, float)  {cls->SetMaxYShiftSpeed(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CAutoCamera, GetMaxAllowedYShift_s, float*)   {*p1 = cls->GetMaxAllowedYShift(); return S_OK;}
    ATTRIBUTE_METHOD1(CAutoCamera, SetMaxAllowedYShift_s, float)    {cls->SetMaxAllowedYShift(p1); return S_OK;}

    ATTRIBUTE_METHOD1(CAutoCamera, IsControlBiped_s, bool*) { *p1 = cls->IsControlBiped(); return S_OK; }
    ATTRIBUTE_METHOD1(CAutoCamera, SetControlBiped_s, bool) { cls->SetControlBiped(p1); return S_OK; }

    ATTRIBUTE_METHOD1(CAutoCamera, IsEnableBlockCollision_s, bool*) { *p1 = cls->IsEnableBlockCollision(); return S_OK; }
    ATTRIBUTE_METHOD1(CAutoCamera, SetEnableBlockCollision_s, bool) { cls->SetEnableBlockCollision(p1); return S_OK; }

    ATTRIBUTE_METHOD1(CAutoCamera, IsIgnoreEyeBlockCollisionInSunlight_s, bool*)    { *p1 = cls->IsIgnoreEyeBlockCollisionInSunlight(); return S_OK; }
    ATTRIBUTE_METHOD1(CAutoCamera, SetIgnoreEyeBlockCollisionInSunlight_s, bool)    { cls->SetIgnoreEyeBlockCollisionInSunlight(p1); return S_OK; }

    ATTRIBUTE_METHOD1(CAutoCamera, GetRenderOrigin_s, Vector3*) { *p1 = cls->GetRenderOrigin(); return S_OK; }
    ATTRIBUTE_METHOD1(CAutoCamera, GetViewProjMatrix_s, Matrix4*)   { *p1 = *(cls->GetViewProjMatrix()); return S_OK; }
    ATTRIBUTE_METHOD1(CAutoCamera, GetViewMatrix_s, Matrix4*)   { *p1 = *(cls->GetViewMatrix()); return S_OK; }
    ATTRIBUTE_METHOD1(CAutoCamera, GetProjMatrix_s, Matrix4*)   { *p1 = *(cls->GetProjMatrix()); return S_OK; }
    
    ATTRIBUTE_METHOD(CAutoCamera, UpdateBipedFlyDir_s)  { cls->UpdateBipedFlyDir(); return S_OK; }

    
    CEventBinding * GetEventBinding();
    void LoadDefaultEventBinding();
    
    virtual VOID FrameMove( FLOAT fElapsedTime );

    void UpdateBipedFlyDir(CBipedObject * pBiped = NULL);
    CBipedObject * GetTargetAsBiped();

    virtual LRESULT HandleMessages(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
    virtual void SetViewParams(const DVector3& vEyePt, const DVector3& vLookatPt);
    
    void FollowBiped( CBaseObject* pBiped, CameraMode modeCamera, double dTransitionTime);
    void FollowBiped( CBaseObject* pBiped, int nTranstionMode, int modeCamera, double Param0, double Param1, double Param2);
    void SetCameraMode(CameraMode modeCamera);
    virtual CameraMode GetCameraMode();

    virtual void SetFollowTarget(CBaseObject* pObj){m_pTargetObject = pObj;};
    virtual CBaseObject* GetFollowTarget(){return m_pTargetObject;};

    bool SmoothMove(DVector3* result, DVector3 vPosTarget, DVector3 vPos, float fIncrease, float fTolerance = 0);

    void UpdateViewProjMatrix();
    Matrix4* GetViewProjMatrix();
    void ComputeViewMatrix(Matrix4 *pOut, const DVector3 *pEye, const DVector3 *pAt, const Vector3 *pUp);

    void UpdateViewMatrix();

    void HandleUserInput();

    bool IsAlwaysRun() {return  m_bAlwaysRun;}
    void SetAlwaysRun(bool bAlwaysRun) {m_bAlwaysRun = bAlwaysRun;}

    bool IsCameraMoved();

    Vector3 GetRenderOrigin();

    bool IsCamAlwaysBehindObject() {return  m_bIsCamAlwaysBehindObject;}
    void SetCamAlwaysBehindObject(bool bIsCamAlwaysBehindObject) {m_bIsCamAlwaysBehindObject = bIsCamAlwaysBehindObject;}

    bool IsUseCharacterLookup();

    void SetUseCharacterLookup(bool bUseCharacterLookup);

    bool IsUseCharacterLookupWhenMounted();

    void SetUseCharacterLookupWhenMounted(bool bUseCharacterLookup);

    int GetCharacterLookupBoneIndex();

    void SetCharacterLookupBoneIndex(int nIndex);

    bool IsUseRightButtonBipedFacing() {return  m_bUseRightButtonBipedFacing;}
    void SetUseRightButtonBipedFacing(bool bUseRightButtonBipedFacing) {m_bUseRightButtonBipedFacing = bUseRightButtonBipedFacing;}

    bool IsEnableMouseRightDrag() {return  m_bEnableMouseRightDrag;}

    void EnableMouseRightDrag(bool bEnabled) {m_bEnableMouseRightDrag = bEnabled;}

    bool IsEnableMouseLeftDrag() {return  m_bEnableMouseLeftDrag;}

    void EnableMouseLeftDrag(bool bEnabled) {m_bEnableMouseLeftDrag = bEnabled;}
    
    bool IsLockMouseWhenDragging() const;
    void SetLockMouseWhenDragging(bool val);

    void Reset();
    void FreeCameraMode();
    void FollowMode();

    float GetKeyboardMovVelocity();
    void SetKeyboardMovVelocity(float fValue);


    float GetKeyboardRotVelocity();
    void SetKeyboardRotVelocity(float fValue);

    void EnableStereoVision(bool bEnable) {m_bEnableStereoVision = bEnable;};
    bool IsStereoVisionEnabled() {return m_bEnableStereoVision;};
    
    void SetStereoEyeShiftDistance(float fDist) {m_fStereoEyeShiftDistance = fDist;} 
    float GetStereoEyeShiftDistance() {return m_fStereoEyeShiftDistance;} 

    void SetCameraObjectDistance(double fDist);
    double GetCameraObjectDistance() { return m_fCameraObjectDistance; }

    void SetCameraLiftupAngle(double fValue) { m_fCameraLiftupAngle = fValue; }
    double GetCameraLiftupAngle() {return m_fCameraLiftupAngle;} 

    void SetCameraRotX(double fValue) { m_fCameraRotX = fValue; }
    double GetCameraRotX() { return m_fCameraRotX; }

    void SetCameraRotY(double fValue) { m_fCameraRotY = fValue; }
    double GetCameraRotY() { return m_fCameraRotY; }

    void SetCameraRotZ(double fValue) { m_fCameraRotZ = fValue; }
    double GetCameraRotZ() { return m_fCameraRotZ; }
    
    void SetLookAtShiftY(double fValue) { m_fLookAtShiftY = fValue; }
    double GetLookAtShiftY() { return m_fLookAtShiftY; }

    void EnableKeyboard(bool bValue); 
    bool GetEnableKeyboard() {return m_bEnableKeyboard;} 

    void EnableMouseLeftButton(bool bValue); 
    bool GetEnableMouseLeftButton() {return m_bEnableMouseLeftButton;} 

    void EnableMouseRightButton(bool bValue); 
    bool GetEnableMouseRightButton() {return m_bEnableMouseRightButton;} 

    void EnableAlwaysRotateCameraWhenFPS(bool bValue); 
    bool GetAlwaysRotateCameraWhenFPS(); 

    void EnableMouseWheel(bool bValue) {m_bEnableMouseWheel = bValue;} 
    bool GetEnableMouseWheel() {return m_bEnableMouseWheel;} 

    void SetPhysicsGroupMask(DWORD dwValue) {m_dwPhysicsGroupMask = dwValue;} 

    DWORD GetPhysicsGroupMask() {return m_dwPhysicsGroupMask;} 

    bool IsBlockInput();
    void SetBlockInput(bool bBlockInput);

    void SetMaxCameraObjectDistance(double fValue) { m_fMaxCameraObjectDistance = fValue; }
    double GetMaxCameraObjectDistance() { return m_fMaxCameraObjectDistance; }

    void SetMinCameraObjectDistance(double fValue) { m_fMinCameraObjectDistance = fValue; }
    double GetMinCameraObjectDistance() { return m_fMinCameraObjectDistance; }

    void SetCameraRollbackSpeed(float fValue) { m_fCameraRollbackSpeed = fValue; } 
    float GetCameraRollbackSpeed() { return m_fCameraRollbackSpeed; } 

    void SetCameraLookatOffset(const Vector3& v) { m_vLookAtOffset = v; } 
    Vector3 GetCameraLookatOffset() { return m_vLookAtOffset; } 

    Vector3 GetAdditionalCameraRotate() const { return m_vAdditionalCameraRotate; }
    void SetAdditionalCameraRotate(const Vector3& val) { m_vAdditionalCameraRotate = val; }

    float GetMaxAllowedYShift();
    void SetMaxAllowedYShift(float fValue);

    float GetMaxYShiftSpeed();
    void SetMaxYShiftSpeed(float fValue);

    bool IsFirstPersonView();

    bool IsControlBiped() const;
    void SetControlBiped(bool val);

    virtual int On_FrameMove(float fElapsedTime);

    bool IsEnableBlockCollision() const;
    void SetEnableBlockCollision(bool val);

    bool IsIgnoreEyeBlockCollisionInSunlight() const { return m_bIgnoreEyeBlockCollisionInSunlight; }
    void SetIgnoreEyeBlockCollisionInSunlight(bool val) { m_bIgnoreEyeBlockCollisionInSunlight = val; }

    virtual Vector3 GetRenderEyePosition();

private:
    void SetKeyDownState(CharacterAndCameraKeys nKey, bool bIsKeyDown);

    void SetDefaultAngles();

    /* as if no key button is pressed. used before disable key board*/
    void ClearKeyStates();

    /* as if no mouse button is down. used before disable mouse */
    void ClearMouseStates();

    void SetMouseDragLock(bool bLock);
    
public:
    BOOL                m_bIsFollowMode;            
    bool                m_bIsLastFrameChanged;  

private: 
    Matrix4 m_matViewProj;
    bool m_bEnableKeyboard;
    bool m_bEnableMouseLeftButton;
    bool m_bEnableMouseRightButton;
    bool m_bEnableMouseWheel;

    CBaseObject*        m_pTargetObject;            
    CameraMode          m_currentCameraMode;        
    
    CameraMode          m_lastCameraMode;           
    double              m_dTransitionAmt;           


    DVector3            m_vEyeLast;                 
    FLOAT               m_fEyeSpeed;                
    DVector3            m_vLookAtLast;              
    DVector3            m_vRenderEyePos;
    FLOAT               m_fLookAtSpeed;             
    Vector3         m_vLookUpLast;              
    FLOAT               m_fLookUpSpeed;             

    /*parameter about each of the camera mode*/
    FLOAT               m_fMaximumHeight;   
    FLOAT               m_fMinimumHeight;   
    FLOAT               m_fKeyboardRotVelocity; 
    FLOAT               m_fKeyboardMovVelocity; 
    double              m_fCameraObjectDistance;
    double              m_fMaxCameraObjectDistance;
    double              m_fMinCameraObjectDistance;
    double              m_fLastCameraObjectDistance;
    double              m_fCameraLiftupAngle;
    double              m_fCameraRotX;
    double              m_fCameraRotY;
    double              m_fCameraRotZ;
    bool                m_bIsCamAlwaysBehindObject;
    double m_fLookAtShiftY;

    float m_fCamZoomSpeed;

    bool                m_bControlBiped;
    
    bool                m_bAlwaysRun;
    CameraConstraint    m_constrants;

    CEventBinding *m_event;
    float m_fCameraRollbackSpeed;
    int m_nForceNoRollbackFrames;

    bool m_bEnableStereoVision;

    float m_fStereoEyeShiftDistance;

    // the pixel mouse drag distance from a mouse down and mouse move
    int  m_nMouseDragDistance;    

    DWORD m_dwPhysicsGroupMask;

    bool m_bUseRightButtonBipedFacing;

    bool m_bEnableMouseLeftDrag;

    bool m_bEnableMouseRightDrag;

    bool m_bUseCharacterLookup;

    bool m_bUseCharacterLookupWhenMounted;

    int m_nCharacterLookupBoneIndex;

    bool m_bAlwaysRotateCameraWhenFPS;

    bool m_bBlockInput;

    //whether to 
    bool m_resetFlyNormal;

    bool m_bFirstPerson;

    bool m_bEnableBlockCollision;

    bool m_bIgnoreEyeBlockCollisionInSunlight;

    bool m_bLockMouseWhenDragging;
    
    Vector3 m_bipedFlyNormal;

    Vector3 m_vLookAtOffset;
    Vector3 m_vAdditionalCameraRotate;
    
    float m_fAllowedCharYShift;
    float m_fMaxYShiftSpeed;
    double m_fLastCharY;
    double m_fLastUsedCharY;
public:
    friend CSceneObject;
    friend ShadowVolume;
};

}