MousePoles.h

Go to the documentation of this file.

#ifndef MOUSE_POLES_UTIL_H
#define MOUSE_POLES_UTIL_H

#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>

namespace glutil
{

    class ViewProvider
    {
    public:
        virtual ~ViewProvider() {}

        virtual glm::mat4 CalcMatrix() const = 0;
    };

    enum MouseButtons
    {
        MB_LEFT_BTN = 1,    
        MB_MIDDLE_BTN,      
        MB_RIGHT_BTN,       
    };

    enum MouseModifiers
    {
        MM_KEY_SHIFT =  0x01,   
        MM_KEY_CTRL =   0x02,   
        MM_KEY_ALT =    0x04,   
    };

    struct ObjectData
    {
        glm::vec3 position;         
        glm::fquat orientation;     
    };

    class ObjectPole
    {
    public:
        ObjectPole(const ObjectData &initialData, float rotateScale,
            MouseButtons actionButton, const ViewProvider *pLookatProvider);

        glm::mat4 CalcMatrix() const;

        void SetRotationScale(float rotateScale);
        float GetRotationScale() const {return m_rotateScale;}

        const ObjectData &GetPosOrient() const {return m_po;}

        void Reset();



        void MouseClick(MouseButtons button, bool isPressed, int modifiers,
            const glm::ivec2 &position);

        void MouseMove(const glm::ivec2 &position);

        void MouseWheel(int direction, int modifiers, const glm::ivec2 &position);

        void CharPress(char key);

        bool IsDragging() const {return m_bIsDragging;}

    private:
        enum Axis
        {
            AXIS_X,
            AXIS_Y,
            AXIS_Z,

            NUM_AXES,
        };

        enum RotateMode
        {
            RM_DUAL_AXIS,
            RM_BIAXIAL,
            RM_SPIN,
        };

        void RotateWorldDegrees(const glm::fquat &rot, bool bFromInitial = false);
        void RotateLocalDegrees(const glm::fquat &rot, bool bFromInitial = false);
        void RotateViewDegrees(const glm::fquat &rot, bool bFromInitial = false);

        const ViewProvider *m_pView;
        ObjectData m_po;
        ObjectData m_initialPo;

        float m_rotateScale;
        MouseButtons m_actionButton;

        //Used when rotating.
        RotateMode m_RotateMode;
        bool m_bIsDragging;

        glm::ivec2 m_prevMousePos;
        glm::ivec2 m_startDragMousePos;
        glm::fquat m_startDragOrient;
    };

    struct ViewData
    {
        glm::vec3 targetPos;    
        glm::fquat orient;      
        float radius;           
        float degSpinRotation;  
    };

    struct ViewScale
    {
        float minRadius;        
        float maxRadius;        
        float largeRadiusDelta; 
        float smallRadiusDelta; 
        float largePosOffset;   
        float smallPosOffset;   
        float rotationScale;    
    };

    class ViewPole : public ViewProvider
    {
    public:
        ViewPole(const ViewData &initialView, const ViewScale &viewScale,
            MouseButtons actionButton = MB_LEFT_BTN, bool bRightKeyboardCtrls = false);
        virtual ~ViewPole() {}

        glm::mat4 CalcMatrix() const;

        void SetRotationScale(float rotateScale);

        float GetRotationScale() const {return m_viewScale.rotationScale;}

        const ViewData &GetView() const {return m_currView;}

        void Reset();


        void MouseClick(MouseButtons button, bool isPressed, int modifiers, const glm::ivec2 &position);
        void MouseMove(const glm::ivec2 &position);
        void MouseWheel(int direction, int modifiers, const glm::ivec2 &position);
        void CharPress(char key);

        bool IsDragging() const {return m_bIsDragging;}

    private:
        enum TargetOffsetDir
        {
            DIR_UP,
            DIR_DOWN,
            DIR_FORWARD,
            DIR_BACKWARD,
            DIR_RIGHT,
            DIR_LEFT,
        };

        void OffsetTargetPos(TargetOffsetDir eDir, float worldDistance);
        void OffsetTargetPos(const glm::vec3 &cameraOffset);

        enum RotateMode
        {
            RM_DUAL_AXIS_ROTATE,
            RM_BIAXIAL_ROTATE,
            RM_XZ_AXIS_ROTATE,
            RM_Y_AXIS_ROTATE,
            RM_SPIN_VIEW_AXIS,
        };

        ViewData m_currView;
        ViewScale m_viewScale;

        ViewData m_initialView;
        MouseButtons m_actionButton;
        bool m_bRightKeyboardCtrls;

        //Used when rotating.
        bool m_bIsDragging;
        RotateMode m_RotateMode;

        float m_degStarDragSpin;
        glm::ivec2 m_startDragMouseLoc;
        glm::fquat m_startDragOrient;

        void ProcessXChange(int iXDiff, bool bClearY = false);
        void ProcessYChange(int iYDiff, bool bClearXZ = false);
        void ProcessXYChange(int iXDiff, int iYDiff);
        void ProcessSpinAxis(int iXDiff, int iYDiff);

        void BeginDragRotate(const glm::ivec2 &ptStart, RotateMode rotMode = RM_DUAL_AXIS_ROTATE);
        void OnDragRotate(const glm::ivec2 &ptCurr);
        void EndDragRotate(const glm::ivec2 &ptEnd, bool bKeepResults = true);

        void MoveCloser(bool bLargeStep = true);
        void MoveAway(bool bLargeStep = true);
    };
}



#endif //MOUSE_POLES_UTIL_H