NavEngines.h

//
// NavEngines.h
//
// Navigation Engines, generally for moving the camera with mouse input.
//
// Copyright (c) 2001-2006 Virtual Terrain Project
// Free for all uses, see license.txt for details.
//

#ifndef NAVENGINESH
#define NAVENGINESH

#include "vtdata/HeightField.h"
#include "Engine.h"
#include "Event.h"



class vtFlyer : public vtLastMouse
{
public:
    vtFlyer(float fSpeed = 1.0f, bool bAllowRoll = false);

    void SetSpeed(float fSpeed) { m_fSpeed = fSpeed; }
    float GetSpeed() { return m_fSpeed; }

    void SetAlwaysMove(bool bMove);
    void SetMultiplier(float fMult) { m_fMult = fMult; }

    void Eval();

    enum DOF { DOF_X = 0, DOF_Y, DOF_Z, DOF_PITCH, DOF_YAW, DOF_ROLL };
    void SetDOF(DOF dof, bool bTrue) { m_bDOF[dof] = bTrue; }
    bool GetDOF(DOF dof) { return m_bDOF[dof]; }

    float GetCurrentSpeed() { return m_fCurrentSpeed; }

protected:
    void DoKeyNavigation();

    float   m_fSpeed;       // max units per frame of movement
    float   m_fMult;        // multiply speed by this factor
    bool    m_bDOF[6];      // six degrees of freedom
    bool    m_bAlwaysMove;
    float   m_fCurrentSpeed; // current speed (most recent frame)

protected:
    ~vtFlyer() {}
};

class vtOrthoFlyer : public vtFlyer
{
public:
    vtOrthoFlyer(float fSpeed);
    void Eval();
};

class vtTerrainFlyer : public vtFlyer
{
public:
    vtTerrainFlyer(float fSpeed, bool bAllowRoll = false);

    void SetHeightField(vtHeightField3d *pHF) { m_pHeightField = pHF; }

    // If true, exaggerate the speed of the view by height above ground
    void SetExag(bool bDo) { m_bExag = bDo; }
    bool GetExag() { return m_bExag; }

    // override
    void Eval();

protected:
    vtHeightField3d *m_pHeightField;
    bool    m_bExag;        // exaggerate speed based on height

protected:
    ~vtTerrainFlyer() {}
};


class vtPanoFlyer : public vtTerrainFlyer
{
public:
    vtPanoFlyer(float fSpeed);

    void Eval();

protected:
    float   m_Velocity;
};


class vtTin3d;

class vtTinFlyer : public vtLastMouse
{
public:
    vtTinFlyer(float fSpeed);

    void SetSpeed(float fSpeed) { m_fSpeed = fSpeed; }
    float GetSpeed() { return m_fSpeed; }

    void SetTin(vtTin3d *pTin);

    // implementation override
    void Eval();

protected:
    float   m_fSpeed;   // max units per frame of movement
    vtTin3d *m_pTin;
    float   m_fPitch;
};


class vtHeightConstrain;

class VFlyer : public vtTerrainFlyer
{
public:
    VFlyer(float scale);

    void SetVerticalVelocity(float velocity);

    void SetGravity(float grav) { m_fGravity = grav; }

    void SetGroundTester(vtHeightConstrain *pEng) { m_pConstrain = pEng; }

    void SetDamping(float damp) { m_fDamping = damp; }

    void Eval();    // overrides

protected:
    FPoint3 m_Velocity;
    float   m_last_time;
    float   m_fGravity;
    float   m_fDamping;
    vtHeightConstrain *m_pConstrain;
};


class QuakeFlyer : public vtTerrainFlyer
{
public:
    QuakeFlyer(float scale);
    void Eval();

    // override
    void OnKey(int key, int flags);

protected:
    IPoint2 m_LastMousePt;
    float   m_flastmovex, m_flastmovey;
    short   m_sWrap;
    bool    m_bNavEnable;
};


class vtHeightConstrain : public vtEngine
{
public:
    vtHeightConstrain(float fMinHeight);

    void SetHeightField(vtHeightField3d *pHF) { m_pHF = pHF; }

    void SetMinGroundOffset(float fMeters) { m_fMinGroundOffset = fMeters; }

    float GetMinGroundOffset() { return m_fMinGroundOffset; }

    void SetUseCulture(bool set) { m_bUseCulture = set; }

    bool GetUseCulture() { return m_bUseCulture; }

    void SetMaintain(bool bMaintain) { m_bMaintain = bMaintain; }
    bool GetMaintain() { return m_bMaintain; }

    void SetMaintainHeight(float fHeight) { m_fMaintainHeight = fHeight; }

    bool IsVerticallyMobile();

    void Eval();

protected:
    bool    m_bMaintain;
    float   m_fMaintainHeight;
    vtHeightField3d *m_pHF;
    float m_fMinGroundOffset;
    bool    m_bUseCulture;
    bool    m_bOnGround;

protected:
    ~vtHeightConstrain() {}
};



class vtTrackball : public vtLastMouse
{
public:
    vtTrackball(float fRadius);

    void SetRadius(float fRadius);
    float GetRadius() const;

    void SetPivotPoint(const FPoint3 &pos) { m_Pivot = pos; }
    FPoint3 GetPivotPoint() const { return m_Pivot; }

    void SetRotateButton(int button, int modifier = 0, bool bExact = true);
    void SetZoomButton(int button, int modifier = 0, bool bExact = true);
    void SetTranslateButton(int button, int modifier = 0, bool bExact = true);

    void SetZoomScale(float s);
    void SetRotScale(float s);
    void SetTransScale(float s);

    void SetDirection(float fTheta, float fPhi);
    void MoveDirection(float fTheta, float fPhi);

    void SetTrans(const FPoint3 &trans) { m_Trans = trans; }
    void Translate(const FPoint3 &trans) { m_Trans += trans; }
    FPoint3 GetTrans() const { return m_Trans; }

    void GetState(FPoint3 *state);
    void SetState(const FPoint3 *state);

    void OnMouse(vtMouseEvent &event);
    void Eval();

    void LimitPos(const FPoint3 &min, const FPoint3 &max);
    void LimitTrans(const FPoint3 &min, const FPoint3 &max);

protected:
    bool _IsRotate();
    bool _IsZoom();
    bool _IsTranslate();
    void _ApplyLimits();

    FPoint3 m_Pos, m_Start, m_Trans, m_Pivot;
    bool    m_bRotate;
    bool    m_bZoom;
    bool    m_bTrans;

    IPoint2 m_MouseStart;
    float   m_fZoomScale;
    float   m_fRotScale;
    float   m_fTransScale;

    int     m_rotate_button;
    int     m_rotate_modifier;
    bool    m_rotate_exact;
    int     m_zoom_button;
    int     m_zoom_modifier;
    bool    m_zoom_exact;
    int     m_trans_button;
    int     m_trans_modifier;
    bool    m_trans_exact;

    // Limits
    FPoint3 m_pos_min, m_pos_max;
    FPoint3 m_trans_min, m_trans_max;

protected:
    ~vtTrackball() {}
};
    // Group nav

#endif