inputevent.h

/* This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// Local Includes
#include "keyboard.h"
#include "controller.h"
 
// External Includes
#include <rtti/rtti.h>
#include <nap/numeric.h>
#include <nap/event.h>
#include <string.h>
 
namespace nap
{
    namespace input
    {
        inline constexpr int invalid = -1;  
    }
 
    class NAPAPI InputEvent : public Event
    {
        RTTI_ENABLE(Event)
    };
 
 
    class NAPAPI WindowInputEvent : public InputEvent
    {
        RTTI_ENABLE(InputEvent)
    public:
        WindowInputEvent(int window) : mWindow(window) { }
        int mWindow;                    
    };
 
 
    // Keyboard Input Events
 
    class NAPAPI KeyEvent : public WindowInputEvent
    {
        RTTI_ENABLE(WindowInputEvent)
    public:
        KeyEvent(EKeyCode inKey, KeyModifier inMod, int window) : WindowInputEvent(window),
            mKey(inKey), mModifier(inMod)
        { }
        
        EKeyCode mKey;              
        KeyModifier mModifier;      
    };
 
 
    class NAPAPI KeyPressEvent : public KeyEvent
    {
        RTTI_ENABLE(KeyEvent)
    public:
        KeyPressEvent(EKeyCode inKey, KeyModifier inMod, int window) :
            KeyEvent(inKey, inMod, window) 
        { }
 
        nap::uint toUtf8() const { return nap::toUtf8(mKey, mModifier); }
    };
 
 
    class NAPAPI KeyReleaseEvent : public KeyEvent
    {
        RTTI_ENABLE(KeyEvent)
    public:
        KeyReleaseEvent(EKeyCode inKey, KeyModifier inMod, int window) :
            KeyEvent(inKey, inMod, window) 
        { }
    };
 
 
 
    // Text input event
 
    class NAPAPI TextInputEvent : public WindowInputEvent
    {
        RTTI_ENABLE(WindowInputEvent)
    public:
        TextInputEvent(const std::string& text, int window) :
            WindowInputEvent(window), mText(text)
        { }
 
        std::string mText;                  
    };
 
 
    // Pointer Input Events, always associated with a with a window
 
    class NAPAPI PointerEvent : public WindowInputEvent
    {
        RTTI_ENABLE(WindowInputEvent)
    public:
 
        enum class ESource : int8
        {
            Mouse = 0,                          
            Touch = 1                           
        };
 
        PointerEvent(int inX, int inY, int window, ESource origin) :
            WindowInputEvent(window), mX(inX), mY(inY), mSource(origin)
        { }
 
        int         mX;                         
        int         mY;                         
        ESource     mSource = ESource::Mouse;   
    };
    
 
    class NAPAPI PointerClickEvent : public PointerEvent
    {
        RTTI_ENABLE(PointerEvent)
    public:
 
        enum class EButton : int8
        {
            UNKNOWN     = -1,
            LEFT        = 0,
            RIGHT       = 1,
            MIDDLE      = 2
        };
 
        PointerClickEvent(int inX, int inY, EButton inButton, int window, ESource source) :
            PointerEvent(inX, inY, window, source),
            mButton(inButton)
        { }
 
        EButton mButton;                
    };
    
 
    class NAPAPI PointerPressEvent : public PointerClickEvent
    {
        RTTI_ENABLE(PointerClickEvent)
    public:
        PointerPressEvent(int inX, int inY, EButton inButton, int window, ESource source) :
            PointerClickEvent(inX, inY, inButton, window, source)
        { }
    };
    
 
    class NAPAPI PointerReleaseEvent : public PointerClickEvent
    {
        RTTI_ENABLE(PointerClickEvent)
    public:
        PointerReleaseEvent (int inX, int inY, EButton inButton, int window, ESource source) :
            PointerClickEvent(inX, inY, inButton, window, source)
        { }
    };
 
 
    class NAPAPI PointerMoveEvent : public PointerEvent
    {
        RTTI_ENABLE(PointerEvent)
    public:
        PointerMoveEvent(int relX, int relY, int inAbsX, int inAbsY, int window, ESource source) :
            PointerEvent(inAbsX, inAbsY, window, source),
            mRelX(relX),
            mRelY(relY)
        { }
 
        int mRelX;                          
        int mRelY;                          
    };
 
 
    class NAPAPI MouseWheelEvent : public WindowInputEvent
    {
        RTTI_ENABLE(WindowInputEvent)
    public:
        MouseWheelEvent(int x, int y, int window=0) : 
            WindowInputEvent(window),
            mX(x),
            mY(y)
        { }
 
        int mX;
        int mY;
    };
 
 
    // Touch Input Events
 
    class NAPAPI TouchEvent : public WindowInputEvent
    {
        RTTI_ENABLE(WindowInputEvent)
    public:
        TouchEvent(int fingerID, int touchID, float x, float y, float pressure, int window = input::invalid, int wx = input::invalid, int wy = input::invalid) :
            WindowInputEvent(window), 
            mFingerID(fingerID),
            mTouchID(touchID),
            mX(x), mY(y),
            mPressure(pressure),
            mXCoordinate(wx), mYCoordinate(wy)
        { }
 
        int mFingerID;                          
        int mTouchID;                           
        float mX;                               
        float mY;                               
        float mPressure;                        
        int mXCoordinate;                       
        int mYCoordinate;                       
 
        bool hasWindow() const                  { return mWindow != input::invalid; }
    };
 
 
    class NAPAPI TouchPressEvent : public TouchEvent
    {
        RTTI_ENABLE(TouchEvent)
    public:
        TouchPressEvent(int fingerID, int touchID, float x, float y, float pressure, int window = input::invalid, int wx = input::invalid, int wy = input::invalid) :
            TouchEvent(fingerID, touchID, x, y, pressure, window, wx, wy)
        { }
    };
 
 
    class NAPAPI TouchReleaseEvent : public TouchEvent
    {
        RTTI_ENABLE(TouchEvent)
    public:
        TouchReleaseEvent(int fingerID, int touchID, float x, float y, float pressure, int window = input::invalid, int wx = input::invalid, int wy = input::invalid) :
            TouchEvent(fingerID, touchID, x, y, pressure, window, wx, wy)
        { }
    };
 
 
    class NAPAPI TouchMoveEvent : public TouchEvent
    {
        RTTI_ENABLE(TouchEvent)
    public:
        TouchMoveEvent(int fingerID, int touchID, float x, float y, float pressure, float dx, float dy, int window = input::invalid, int wx = input::invalid, int wy = input::invalid) :
            TouchEvent(fingerID, touchID, x, y, pressure, window, wx, wy),
            mDX (dx), mDY (dy)
        { }
 
        float mDX;                              
        float mDY;                              
    };
 
 
    // Controller Input Events
 
    class NAPAPI ControllerEvent : public InputEvent
    {
        RTTI_ENABLE(InputEvent)
    public:
        ControllerEvent(int deviceID) :
            mDeviceID(deviceID) { }
 
        int mDeviceID = -1;                                             
    };
 
    class NAPAPI ControllerAxisEvent : public ControllerEvent
    {
        RTTI_ENABLE(ControllerEvent)
    public:
        ControllerAxisEvent(int deviceID, EControllerAxis axis, int axisID, double value) : 
            ControllerEvent(deviceID),
            mAxis(axis),
            mAxisID(axisID),
            mValue(value) { }
 
        EControllerAxis mAxis = EControllerAxis::UNKNOWN;               
        int mAxisID = -1;                                               
        double mValue = 0.0;                                            
    };
 
    class NAPAPI ControllerButtonEvent : public ControllerEvent
    {
        RTTI_ENABLE(ControllerEvent)
    public:
        ControllerButtonEvent(int deviceID, EControllerButton button, int buttonID) :
            ControllerEvent(deviceID),
            mButton(button),
            mButtonID(buttonID) { }
 
        EControllerButton mButton = EControllerButton::UNKNOWN;         
        int mButtonID = -1;                                             
    };
 
 
    class NAPAPI ControllerButtonPressEvent : public ControllerButtonEvent
    {
        RTTI_ENABLE(ControllerButtonEvent)
    public:
        ControllerButtonPressEvent(int deviceID, EControllerButton button, int buttonID) :
            ControllerButtonEvent(deviceID, button, buttonID) { }
    };
 
 
    class NAPAPI ControllerButtonReleaseEvent : public ControllerButtonEvent
    {
        RTTI_ENABLE(ControllerButtonEvent)
    public:
        ControllerButtonReleaseEvent(int deviceID, EControllerButton button, int buttonID) :
            ControllerButtonEvent(deviceID, button, buttonID) { }
    };
 
 
    class NAPAPI ControllerConnectionEvent : public ControllerEvent
    {
        RTTI_ENABLE(ControllerEvent)
    public:
        ControllerConnectionEvent(int deviceID, bool connected) : 
            ControllerEvent(deviceID),
            mConnected(connected) { }
        bool mConnected = false;                                    
    };
 
 
    using InputEventPtr = std::unique_ptr<nap::InputEvent>;
    using InputEventPtrList = std::vector<InputEventPtr>;
}