F:/My Projects/LSEngine/Modules/LSEngine/Src/Input/LSEMouse.h

#ifndef __LSE_MOUSE_H__
#define __LSE_MOUSE_H__

#include "../LSEEngine.h"
#include "Vector/LSMVector2.h"


// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
// MACROS
// * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
// Number of buttons on a mouse.  Change it to support as many as you want (but you will
//      also have to make a way to send clicks to the extra slots).
#define __LSE_MOUSE_BUTTONS__                   3
// Number of history items in the mouse-smoothening array.
#define __LSE_MOUSE_SMOOTH_HISTORY__    50

namespace lse {

        class CMouse {
        public :
                // == Various constructors.
                LSE_INLINE LSE_CALL                             CMouse();


                // == Functions.
                const CVector2 & LSE_CALL               GetPos() const;

                const CVector2 & LSE_CALL               GetLastPos() const;

                CVector2 LSE_CALL                               GetDelta() const;

                LSREAL LSE_CALL                                 GetXDelta() const;

                LSREAL LSE_CALL                                 GetYDelta() const;

                const CVector2 & LSE_CALL               GetInterpPos() const;

                const CVector2 & LSE_CALL               GetInterpLastPos() const;

                CVector2 LSE_CALL                               GetInterpDelta() const;

                LSREAL LSE_CALL                                 GetInterpXDelta() const;

                LSREAL LSE_CALL                                 GetInterpYDelta() const;


                LSVOID LSE_CALL                                 SetPos( LSREAL _fX, LSREAL _fY );

                LSVOID LSE_CALL                                 AddPos( LSREAL _fX, LSREAL _fY );

                LSVOID LSE_CALL                                 ApplyChanges( LSUINT64 _ui64TimeStamp );

                LSVOID LSE_CALL                                 SetStartPos( LSREAL _fX, LSREAL _fY );

                LSVOID LSE_CALL                                 Snap( LSREAL _fX, LSREAL _fY, LSREAL _fRight, LSREAL _fBottom );

                LSVOID LSE_CALL                                 Click( LSUINT32 _ui32Index );

                LSVOID LSE_CALL                                 UnClick( LSUINT32 _ui32Index );

                LSBOOL LSE_CALL                                 IsMouseButtonDown( LSUINT32 _ui32Index ) const;

                LSBOOL LSE_CALL                                 MouseButtonJustPressed( LSUINT32 _ui32Index ) const;

                LSBOOL LSE_CALL                                 MouseButtonJustReleased( LSUINT32 _ui32Index ) const;

                LSVOID LSE_CALL                                 ResetClicks();

                const LSINT16 * LSE_CALL                GetIndexMap() const;


        protected :
                // == Types.
                struct LSE_MOUSE_MOVE_POS {
                        CVector2                                        vPos;

                        LSUINT64                                        ui64Time;
                };


                // == Members.
                CVector2                                                m_vPos;

                CVector2                                                m_vTempPos;

                CVector2                                                m_vLastPos;

                CVector2                                                m_vInterpPos;

                CVector2                                                m_vLastInterpPos;

                LSE_MOUSE_MOVE_POS                              m_mmpHistory[__LSE_MOUSE_SMOOTH_HISTORY__];

                LSUINT32                                                m_ui32HistorySize               : 30;

                LSUINT32                                                m_ui32UpdateMoveBuffer  : 2;

                LSUINT32                                                m_ui32InterpTime;

                LSUINT64                                                m_ui64TimeNow;

                LSINT32                                                 m_i32ClickCountBuffer[__LSE_MOUSE_BUTTONS__];
                LSINT32                                                 m_i32ClickCount[__LSE_MOUSE_BUTTONS__];

                LSINT32                                                 m_i32UnClickCount[__LSE_MOUSE_BUTTONS__];

                // States of each button at the last update.
                LSINT32                                                 m_i32LastClickState[__LSE_MOUSE_BUTTONS__];

                // Input mapping.  The source index is the index into this array.
                //      the destination index is the value at that index.  Defaults
                //      to a one-to-one mapping where the source and destination
                //      values are the same.
                LSINT16                                                 m_i16IndexMap[__LSE_MOUSE_BUTTONS__];


                // == Functions.
                LSUINT64 LSE_CALL                               GetMostRecentHistoryTime() const;

                LSUINT32 LSE_CALL                               FindTimeStampByTime( LSUINT64 _ui64Time ) const;

                CVector2 LSE_CALL                               GetInterpolatedPos() const;
        };


        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // DEFINITIONS
        // * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
        // == Various constructors.
        LSE_INLINE LSE_CALL CMouse::CMouse() :
                m_ui32HistorySize( 0 ),
                m_ui32UpdateMoveBuffer( 0 ),
                m_ui32InterpTime( 8000 ),
                m_ui64TimeNow( 0ULL ) {
                for ( LSUINT32 I = 0; I < LSE_ELEMENTS( m_i32ClickCount ); ++I ) {
                        m_i32ClickCountBuffer[I] = m_i32ClickCount[I] = m_i32UnClickCount[I] = m_i32LastClickState[I] = 0;
                        m_i16IndexMap[I] = static_cast<LSINT16>(I);
                }
        }

        // == Functions.
        LSE_INLINE const CVector2 & LSE_CALL CMouse::GetPos() const {
                return m_vPos;
        }

        LSE_INLINE const CVector2 & LSE_CALL CMouse::GetLastPos() const {
                return m_vLastPos;
        }

        LSE_INLINE CVector2 LSE_CALL CMouse::GetDelta() const {
                return CVector2( m_vPos.x - m_vLastPos.x, m_vPos.y - m_vLastPos.y );
        }

        LSE_INLINE LSREAL LSE_CALL CMouse::GetXDelta() const {
                return m_vPos.x - m_vLastPos.x;
        }

        LSE_INLINE LSREAL LSE_CALL CMouse::GetYDelta() const {
                return m_vPos.y - m_vLastPos.y;
        }

        LSE_INLINE const CVector2 & LSE_CALL CMouse::GetInterpPos() const {
                return m_vInterpPos;
        }

        LSE_INLINE const CVector2 & LSE_CALL CMouse::GetInterpLastPos() const {
                return m_vLastInterpPos;
        }

        LSE_INLINE CVector2 LSE_CALL CMouse::GetInterpDelta() const {
                return m_vInterpPos - m_vLastInterpPos;
        }

        LSE_INLINE LSREAL LSE_CALL CMouse::GetInterpXDelta() const {
                return m_vInterpPos.x - m_vLastInterpPos.x;
        }

        LSE_INLINE LSREAL LSE_CALL CMouse::GetInterpYDelta() const {
                return m_vInterpPos.y - m_vLastInterpPos.y;
        }

        LSE_INLINE LSBOOL LSE_CALL CMouse::IsMouseButtonDown( LSUINT32 _ui32Index ) const {
                assert( _ui32Index < __LSE_MOUSE_BUTTONS__ );
                return m_i32ClickCount[_ui32Index] != 0;
        }

        LSE_INLINE LSBOOL LSE_CALL CMouse::MouseButtonJustPressed( LSUINT32 _ui32Index ) const {
                assert( _ui32Index < __LSE_MOUSE_BUTTONS__ );
                return m_i32ClickCount[_ui32Index] > m_i32LastClickState[_ui32Index];
        }

        LSE_INLINE LSBOOL LSE_CALL CMouse::MouseButtonJustReleased( LSUINT32 _ui32Index ) const {
                assert( _ui32Index < __LSE_MOUSE_BUTTONS__ );
                return m_i32ClickCount[_ui32Index] < m_i32LastClickState[_ui32Index];
        }

        LSE_INLINE LSVOID LSE_CALL CMouse::ResetClicks() {
                // Actually we set the unclick count to a number absurdly high so that the mouse buttons
                //      are guaranteed to be unclicked fully on the next update.
                // We cannot set it too high, however, as we would risk overflow if another unclick
                //      event occurred before the next update.
                // This is why we clip both the click and unclick values to 0x0FFFFFFF.
                for ( LSUINT32 I = 0; I < LSE_ELEMENTS( m_i32ClickCount ); ++I ) {
                        m_i32UnClickCount[I] = 0x0FFFFFFF;
                }
        }

        LSE_INLINE const LSINT16 * LSE_CALL CMouse::GetIndexMap() const { return m_i16IndexMap; }

        LSE_INLINE LSUINT64 LSE_CALL CMouse::GetMostRecentHistoryTime() const {
                if ( m_ui32HistorySize == 0 ) {
                        // No history.
                        return 0ULL;
                }
                return m_mmpHistory[m_ui32HistorySize-1].ui64Time;
        }

        LSE_INLINE LSUINT32 LSE_CALL CMouse::FindTimeStampByTime( LSUINT64 _ui64Time ) const {
                for ( LSUINT32 I = 0; I < m_ui32HistorySize; ++I ) {
                        if ( m_mmpHistory[I].ui64Time >= _ui64Time ) {
                                return I;
                        }
                }
                return __LSE_MOUSE_SMOOTH_HISTORY__;
        }

        LSE_INLINE CVector2 LSE_CALL CMouse::GetInterpolatedPos() const {
                if ( m_ui32HistorySize == 0 ) {
                        // No history.
                        return m_vPos;
                }

                LSUINT32 ui32Index = FindTimeStampByTime( m_ui64TimeNow - m_ui32InterpTime );
                // If none found, we are at the end of the history.
                if ( ui32Index == __LSE_MOUSE_SMOOTH_HISTORY__ ) {
                        return m_vPos;
                }
                if ( ui32Index == 0 ) {
                        // No history item prior to this for interpolating between.
                        return m_mmpHistory[ui32Index].vPos;
                }

                // Now we have positions on both sides of our delayed timestamp, so
                //      we can interpolate between them.
                LSUINT32 ui32DistanceBetweenPos = static_cast<LSUINT32>(m_mmpHistory[ui32Index].ui64Time - m_mmpHistory[ui32Index-1].ui64Time);
                LSUINT32 ui32DistanceBetweenCurTime = static_cast<LSUINT32>((m_ui64TimeNow - m_ui32InterpTime) - m_mmpHistory[ui32Index-1].ui64Time);
                LSREAL fFrac = static_cast<LSREAL>(ui32DistanceBetweenCurTime >> 2UL) / static_cast<LSREAL>(ui32DistanceBetweenPos >> 2UL);

                CVector2 vInterp = m_mmpHistory[ui32Index].vPos - m_mmpHistory[ui32Index-1].vPos;
                return m_mmpHistory[ui32Index-1].vPos + (vInterp * fFrac);
        }

}       // namespace lse

#endif  // __LSE_MOUSE_H__