jmInput.h

#ifndef JUGIMAP_INPUT_H
#define JUGIMAP_INPUT_H
 
#include <assert.h>
#include <algorithm>
#include <cmath>
#include <vector>
#include <array>
#include <string>
 
#include "jmCommon.h"
 
 
namespace jugimap{
    
class Sprite;
 
 
 
 
 
 
struct ButtonState
{
    bool pressed = false;
    bool down = false;
    bool released = false;
 
    void _Set(bool _down);
    void Reset(){ pressed = down = released = false; }
    void ResetPerUpdateFlags(){ pressed = released = false; }
 
};
 
 
enum class KeyCode
{
 
    UNKNOWN = 0,                
 
    BACKSPACE=8,                
    TAB=9,                      
    ENTER=13,                   
    PAUSE=19,                   
    ESCAPE=27,                  
    SPACE=32,                   
 
    PAGEUP=33,                  
    PAGEDOWN=34,                
    END=35,                     
    HOME=36,                    
 
    LEFT=37,                    
    UP=38,                      
    RIGHT=39,                   
    DOWN=40,                    
 
    PRINT=42,                   
    INSERT=45,                  
    DELETEkey=46,               
 
    NUM_0=48,                   
    NUM_1=49,                   
    NUM_2=50,                   
    NUM_3=51,                   
    NUM_4=52,                   
    NUM_5=53,                   
    NUM_6=54,                   
    NUM_7=55,                   
    NUM_8=56,                   
    NUM_9=57,                   
 
    A=65,                       
    B=66,                       
    C=67,                       
    D=68,                       
    E=69,                       
    F=70,                       
    G=71,                       
    H=72,                       
    I=73,                       
    J=74,                       
    K=75,                       
    L=76,                       
    M=77,                       
    N=78,                       
    O=79,                       
    P=80,                       
    Q=81,                       
    R=82,                       
    S=83,                       
    T=84,                       
    U=85,                       
    V=86,                       
    W=87,                       
    X=88,                       
    Y=89,                       
    Z=90,                       
 
    /*
    KEY_NUM0=96,
    KEY_NUM1=97,
    KEY_NUM2=98,
    KEY_NUM3=99,
    KEY_NUM4=100,
    KEY_NUM5=101,
    KEY_NUM6=102,
    KEY_NUM7=103,
    KEY_NUM8=104,
    KEY_NUM9=105,
 
    KEY_NUMMULTIPLY=106,
    KEY_NUMADD=107,
    KEY_NUMSUBTRACT=109,
    KEY_NUMDECIMAL=110,
    KEY_NUMDIVIDE=111,
    */
 
    F1=112,                     
    F2=113,                     
    F3=114,                     
    F4=115,                     
    F5=116,                     
    F6=117,                     
    F7=118,                     
    F8=119,                     
    F9=120,                     
    F10=121,                    
    F11=122,                    
    F12=123,                    
 
 
    // 165 - 190 - reserved for upper case letters using printable characters table
    TILDE=192,                  
    HYPHEN=193,                 
    EQUAL=194,                  
    SEMICOLON=195,              
    QUOTE=196,                  
    COMMA=197,                  
    PERIOD=198,                 
    SLASH=199,                  
    LEFT_BRACKET=200,           
    RIGHT_BRACKET=201,          
    BACKSLASH=202,              
 
    LEFT_SHIFT=210,             
    RIGHT_SHIFT=211,            
    LEFT_CONTROL=212,           
    RIGHT_CONTROL=213,          
    LEFT_ALT=214,               
    RIGHT_ALT=215,              
 
};
 
 
class Keyboard
{
public:
 
    Keyboard();
 
    bool IsKeyPressed(KeyCode _keyCode);
 
    bool IsKeyDown(KeyCode _keyCode);
 
    bool IsKeyReleased(KeyCode _keyCode);
 
    char GetCharPressed(){ return charPressed; }
 
    void Reset();
 
    //-------------------------------------------------------
 
    void ResetPerUpdateFlags();
    void _SetKeyState(KeyCode _keyCode, bool _keyDown);
    std::array<ButtonState,256> & GetKeys(){ return keys; }
    std::vector<std::string> & GetKeysNames(){ return keyNames; }
 
private:
    std::array<ButtonState,256>keys;
    std::vector<char>printableASCIIcodes;
    std::vector<std::string>keyNames;
    char charPressed = 0;
 
};
 
 
extern Keyboard keyboard;
 
 
 
//-------------------------------------------------------------------------------------
 
 
enum class MouseButton
{
    NONE = 0,           
    LEFT = 1,           
    MIDDLE = 2,         
    RIGHT = 3,          
};
 
 
class Mouse
{
public:
 
    int GetX(){ return pos.x; }
 
    int GetY(){ return pos.y; }
 
    Vec2i GetPos(){ return pos; }
 
    bool IsPositionChanged(){ return posChanged; }
 
 
    int GetWheelX(){ return wheel.x; }
 
    int GetWheelY(){ return wheel.y; }
 
    Vec2i GetWheel(){ return wheel; }
 
    bool IsWheelXChanged(){ return wheelXChanged; }
 
    bool IsWheelYChanged(){ return wheelYChanged; }
 
 
    bool IsButtonPressed(MouseButton _mouseButton){ return buttons[(int)_mouseButton].pressed; }
 
    bool IsButtonDown(MouseButton _mouseButton){ return buttons[(int)_mouseButton].down; }
 
    bool IsButtonReleased(MouseButton _mouseButton){ return buttons[(int)_mouseButton].released; }
 
    void SetCursorSprite(jugimap::Sprite *_cursorSprite);
 
    void ClearCursorSprite();
 
    Sprite* GetCursorSprite(){ return cursorSprite; }
 
    void Reset();
 
    //----
 
    void ResetPerUpdateFlags();
    void _SetPosition(Vec2i _pos) { posChanged = ! _pos.Equals(pos);   pos = _pos; }
    void _SetWheel(Vec2i _wheel);
    void _SetButtonState(MouseButton _mouseButton, bool _down);
 
 
private:
 
    Vec2i pos;
    Vec2i wheel;
    std::array<ButtonState,4> buttons;
 
    bool wheelYChanged = false;
    bool wheelXChanged = false;
    bool posChanged =false;
 
    //----
    Sprite *cursorSprite = nullptr;             // LINK
 
};
 
 
extern Mouse mouse;
 
 
 
//-------------------------------------------------------------------------------------
 
 
 
struct Finger : public ButtonState
{
    int id = 0;
    Vec2i position;
};
 
 
class Touch
{
public:
 
 
    bool IsFingerPressed(int _finger){ return fingers[_finger].pressed; }
 
    bool IsFingerDown(int _finger){ return fingers[_finger].down; }
 
    bool IsFingerReleased(int _finger){ return fingers[_finger].released; }
 
    int GetFingerX(int _finger){ return fingers[_finger].position.x; }
 
    int GetFingerY(int _finger){ return fingers[_finger].position.y; }
 
    Vec2i GetFingerPos(int _finger){ return fingers[_finger].position; }
 
    std::array<Finger, 10> & GetFingers(){ return fingers;}
 
    void Reset();
 
    //----
    void ResetPerUpdateFlags();
 
    //----
    void _SetFingerState(int _finger, bool _down, Vec2i _position);
 
private:
 
    std::array<Finger, 10>fingers;
 
};
 
extern Touch touch;
 
 
//-------------------------------------------------------------------------------------
 
 
 
class Joystick
{
public:
 
    enum class POV_X
    {
        NONE,
        RIGHT,
        LEFT
    };
 
    enum class POV_Y
    {
        NONE,
        UP,
        DOWN,
    };
 
 
    static std::string DbgGetPOV_Xstring(POV_X _pov);
    static std::string DbgGetPOV_Ystring(POV_Y _pov);
 
 
    bool IsButtonPressed(int _buttonIndex){ return buttons[_buttonIndex].pressed; }
 
    bool IsButtonDown(int _buttonIndex){ return buttons[_buttonIndex].down; }
 
    bool IsButtonReleased(int _buttonIndex){ return buttons[_buttonIndex].released; }
 
    bool IsPOV_XPressed(POV_X _povX){ return povXButtons[(int)_povX].pressed; }
 
    bool IsPOV_XDown(POV_X _povX){ return povXButtons[(int)_povX].down; }
 
    bool IsPOV_XReleased(POV_X _povX){ return povXButtons[(int)_povX].released; }
 
    bool IsPOV_YPressed(POV_Y _povY){ return povYButtons[(int)_povY].pressed; }
 
    bool IsPOV_YDown(POV_Y _povY){ return povYButtons[(int)_povY].down; }
 
    bool IsPOV_YReleased(POV_Y _povY){ return povYButtons[(int)_povY].released; }
 
    float GetXaxis(){ return xAxis; }
 
    float GetYaxis(){ return yAxis; }
 
    float GetZaxis(){ return zAxis; }
 
    bool IsConnected(){ return connected; }
 
    void Reset();
 
    std::array<ButtonState,16>& GetButtons(){ return buttons;}
 
    std::string GetName(){ return name; }
 
 
    void ResetPerUpdateFlags();
 
    //----
    void _SetPOV_X(POV_X _povX);
    void _SetPOV_Y(POV_Y _povY);
    void _SetXaxis(float _xAxis){ xAxis = _xAxis;}
    void _SetYaxis(float _yAxis){ yAxis = _yAxis;}
    void _SetZaxis(float _zAxis){ zAxis = _zAxis;}
    void _SetButtonState(int _buttonIndex, bool _down);
    void _SetConnected(bool _connected){ connected = _connected; }
    void _SetName(const std::string &_name){ name = _name; }
 
 
private:
    std::array<ButtonState,16>buttons;
    std::array<ButtonState,3>povXButtons;
    std::array<ButtonState,3>povYButtons;
 
 
    float xAxis = 0.0;
    float yAxis = 0.0;
    float zAxis = 0.0;
    bool connected = false;
    std::string name = "Generic joystick";
};
 
 
extern std::array<Joystick, 4>joysticks;
 
 
    
 
}
 
 
 
#endif // JUGIMAP_INPUT_H