Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Jul 20, 2008, 7:49:26 PM (17 years ago)
Author:
rgrieder
Message:

merged input branch into gui test branch (was about time)
svn save (it's still a mess and CMLs haven't been updated)
I'll have to create a special project to create the tolua_bind files for tolua itself anyway..

Location:
code/branches/gui
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • code/branches/gui

  • code/branches/gui/src/core/input/InputManager.h

    r1555 r1638  
    2828
    2929/**
    30  @file
    31  @brief Implementation of a little Input handler that distributes everything
    32         coming from OIS.
    33  */
     30@file
     31@brief
     32    Implementation of a little Input handler that distributes everything
     33    coming from OIS.
     34*/
    3435
    3536#ifndef _InputManager_H__
    … …  
    4041#include <map>
    4142#include <vector>
    42 
     43#include <stack>
    4344#include "util/Math.h"
    4445#include "core/OrxonoxClass.h"
    … …  
    4748namespace orxonox
    4849{
    49   /**
    50   * Helper class to realise a vector<int[4]>
    51   */
    52   class POVStates
    53   {
    54   public:
    55     int operator[](unsigned int index) { return povStates[index]; }
    56     int povStates[4];
    57   };
    58 
    59   /**
    60   * Helper class to realise a vector< {int[4], int[4]} >
    61   */
    62   class SliderStates
    63   {
    64   public:
    65     IntVector2 sliderStates[4];
    66   };
    67 
    68   /**
    69   * Struct for storing a custom input state
    70   */
    71   struct StoredState
    72   {
    73     std::vector<KeyHandler*>                    activeKeyHandlers_;
    74     std::vector<MouseHandler*>                  activeMouseHandlers_;
    75     std::vector<std::vector<JoyStickHandler*> > activeJoyStickHandlers_;
    76     std::vector<std::pair<InputTickable*, HandlerState> > activeHandlers_;
    77   };
    78 
    79   struct JoyStickCalibration
    80   {
    81     int zeroStates[24];
    82     float positiveCoeff[24];
    83     float negativeCoeff[24];
    84   };
    85 
    86   /**
    87     @brief Captures and distributes mouse and keyboard input.
    88   */
    89   class _CoreExport InputManager
     50    /**
     51    @brief
     52        Helper class to realise a vector<int[4]>
     53    */
     54    class POVStates
     55    {
     56    public:
     57        int operator[](unsigned int index) { return povStates[index]; }
     58        int povStates[4];
     59    };
     60
     61    /**
     62    @brief
     63        Helper class to realise a vector< {int[4], int[4]} >
     64    */
     65    class SliderStates
     66    {
     67    public:
     68        IntVector2 sliderStates[4];
     69    };
     70
     71    struct JoyStickCalibration
     72    {
     73        int zeroStates[24];
     74        float positiveCoeff[24];
     75        float negativeCoeff[24];
     76    };
     77
     78    /**
     79    @brief
     80        Captures and distributes mouse and keyboard input.
     81    */
     82    class _CoreExport InputManager
    9083        : public OrxonoxClass,
    91           public OIS::KeyListener, public OIS::MouseListener, public OIS::JoyStickListener
    92   {
    93   public: // enumerations
    94     /**
    95       @brief Designates the way input is handled and redirected.
    96     */
    97     enum InputState
    98     {
    99       IS_UNINIT,    //!< InputManager has not yet been initialised.
    100       IS_NONE,      //!< Input is discarded.
    101       IS_NORMAL,    //!< Normal play state. Key and button bindings are active.
    102       IS_GUI,       //!< All OIS input events are passed to CEGUI.
    103       IS_CONSOLE,   //!< Keyboard input is redirected to the InputBuffer.
    104       IS_DETECT,    //!< All the input additionally goes to the KeyDetector
    105       IS_NODETECT,  //!< remove KeyDetector
    106       IS_NOCALIBRATE,
    107       IS_CALIBRATE,
    108       IS_CUSTOM     //!< Any possible configuration.
    109     };
    110 
    111   public: // member functions
    112     void setConfigValues();
    113 
    114   public: // static functions
    115     static bool initialise(const size_t windowHnd, int windowWidth, int windowHeight,
    116           bool createKeyboard = true, bool createMouse = true, bool createJoySticks = false);
    117     static bool initialiseKeyboard();
    118     static bool initialiseMouse();
    119     static bool initialiseJoySticks();
    120     static int  numberOfKeyboards();
    121     static int  numberOfMice();
    122     static int  numberOfJoySticks();
    123 
    124     static void destroy();
    125     static void destroyKeyboard();
    126     static void destroyMouse();
    127     static void destroyJoySticks();
    128 
    129     //static bool isModifierDown(KeyboardModifier::Enum modifier);
    130     //static bool isKeyDown(KeyCode::Enum key);
    131     //static const MouseState getMouseState();
    132     //static const JoyStickState getJoyStickState(unsigned int ID);
    133 
    134     static void setWindowExtents(const int width, const int height);
    135 
    136     static void setInputState(const InputState state);
    137     static InputState getInputState();
    138 
    139     static void storeKeyStroke(const std::string& name);
    140     static void keyBind(const std::string& command);
    141 
    142     static void calibrate();
    143 
    144     static void tick(float dt);
    145 
    146     static bool addKeyHandler                 (KeyHandler* handler, const std::string& name);
    147     static bool removeKeyHandler              (const std::string& name);
    148     static KeyHandler* getKeyHandler          (const std::string& name);
    149     static bool enableKeyHandler              (const std::string& name);
    150     static bool disableKeyHandler             (const std::string& name);
    151     static bool isKeyHandlerActive            (const std::string& name);
    152 
    153     static bool addMouseHandler               (MouseHandler* handler, const std::string& name);
    154     static bool removeMouseHandler            (const std::string& name);
    155     static MouseHandler* getMouseHandler      (const std::string& name);
    156     static bool enableMouseHandler            (const std::string& name);
    157     static bool disableMouseHandler           (const std::string& name);
    158     static bool isMouseHandlerActive          (const std::string& name);
    159 
    160     static bool addJoyStickHandler            (JoyStickHandler* handler, const std::string& name);
    161     static bool removeJoyStickHandler         (const std::string& name);
    162     static JoyStickHandler* getJoyStickHandler(const std::string& name);
    163     static bool enableJoyStickHandler         (const std::string& name, unsigned int id);
    164     static bool disableJoyStickHandler        (const std::string& name, unsigned int id);
    165     static bool isJoyStickHandlerActive       (const std::string& name, unsigned int id);
    166 
    167   private: // functions
    168     // don't mess with a Singleton
    169     InputManager ();
    170     InputManager (const InputManager&);
    171     ~InputManager();
    172 
    173     // Intenal methods
    174     bool _initialise(const size_t, int, int, bool, bool, bool);
    175     bool _initialiseKeyboard();
    176     bool _initialiseMouse();
    177     bool _initialiseJoySticks();
    178 
    179     void _destroy();
    180     void _destroyKeyboard();
    181     void _destroyMouse();
    182     void _destroyJoySticks();
    183 
    184     void _updateTickables();
    185 
    186     void _saveState();
    187     void _restoreState();
    188 
    189     void _completeCalibration();
    190 
    191     void _fireAxis(unsigned int iJoyStick, int axis, int value);
    192     unsigned int _getJoystick(const OIS::JoyStickEvent& arg);
    193 
    194     void _tick(float dt);
    195 
    196     // input events
    197     bool mousePressed  (const OIS::MouseEvent    &arg, OIS::MouseButtonID id);
    198     bool mouseReleased (const OIS::MouseEvent    &arg, OIS::MouseButtonID id);
    199     bool mouseMoved    (const OIS::MouseEvent    &arg);
    200     bool keyPressed    (const OIS::KeyEvent      &arg);
    201     bool keyReleased   (const OIS::KeyEvent      &arg);
    202     bool buttonPressed (const OIS::JoyStickEvent &arg, int button);
    203     bool buttonReleased(const OIS::JoyStickEvent &arg, int button);
    204     bool axisMoved     (const OIS::JoyStickEvent &arg, int axis);
    205     bool sliderMoved   (const OIS::JoyStickEvent &arg, int id);
    206     bool povMoved      (const OIS::JoyStickEvent &arg, int id);
    207     //bool vector3Moved  (const OIS::JoyStickEvent &arg, int id);
    208 
    209     static InputManager& _getSingleton();
    210     static InputManager* _getSingletonPtr() { return &_getSingleton(); }
    211 
    212   private: // variables
    213     OIS::InputManager*                          inputSystem_;     //!< OIS input manager
    214     OIS::Keyboard*                              keyboard_;        //!< OIS mouse
    215     OIS::Mouse*                                 mouse_;           //!< OIS keyboard
    216     std::vector<OIS::JoyStick*>                 joySticks_;       //!< OIS joy sticks
    217     unsigned int                                joySticksSize_;
    218 
    219     KeyBinder*                                  keyBinder_;       //!< KeyBinder instance
    220     KeyDetector*                                keyDetector_;     //!< KeyDetector instance
    221     InputBuffer*                                buffer_;          //!< InputBuffer instance
    222     CalibratorCallback*                         calibratorCallback_;
    223 
    224     InputState state_;
    225     InputState stateRequest_;
    226     InputState savedState_;
    227     unsigned int keyboardModifiers_;
    228     StoredState savedHandlers_;
    229 
    230     // joystick calibration
    231     //std::vector<int> marginalsMaxConfig_;
    232     //std::vector<int> marginalsMinConfig_;
    233     int marginalsMax_[24];
    234     int marginalsMin_[24];
    235     bool bCalibrated_;
    236 
    237     //! Keeps track of the joy stick POV states
    238     std::vector<POVStates>                      povStates_;
    239     //! Keeps track of the possibly two slider axes
    240     std::vector<SliderStates>                   sliderStates_;
    241     std::vector<JoyStickCalibration>            joySticksCalibration_;
    242 
    243     std::map<std::string, KeyHandler*>          keyHandlers_;
    244     std::map<std::string, MouseHandler*>        mouseHandlers_;
    245     std::map<std::string, JoyStickHandler*>     joyStickHandlers_;
    246 
    247     std::vector<KeyHandler*>                    activeKeyHandlers_;
    248     std::vector<MouseHandler*>                  activeMouseHandlers_;
    249     std::vector<std::vector<JoyStickHandler*> > activeJoyStickHandlers_;
    250     std::vector<std::pair<InputTickable*, HandlerState> > activeHandlers_;
    251 
    252     std::vector<Key>                            keysDown_;
    253     std::vector<MouseButton::Enum>              mouseButtonsDown_;
    254     std::vector<std::vector<int> >              joyStickButtonsDown_;
    255 
    256     static std::string                          bindingCommmandString_s;
    257   };
     84        public OIS::KeyListener, public OIS::MouseListener, public OIS::JoyStickListener
     85    {
     86        // --> setConfigValues is private
     87        friend ClassIdentifier<InputManager>;
     88
     89    public: // static functions
     90        static bool initialise(const size_t windowHnd, int windowWidth, int windowHeight,
     91                               bool createKeyboard = true, bool createMouse = true, bool createJoySticks = false);
     92        static bool initialiseKeyboard();
     93        static bool initialiseMouse();
     94        static bool initialiseJoySticks();
     95        static int  numberOfKeyboards();
     96        static int  numberOfMice();
     97        static int  numberOfJoySticks();
     98
     99        static void destroy();
     100        static void destroyKeyboard();
     101        static void destroyMouse();
     102        static void destroyJoySticks();
     103
     104        //static bool isModifierDown(KeyboardModifier::Enum modifier);
     105        //static bool isKeyDown(KeyCode::Enum key);
     106        //static const MouseState getMouseState();
     107        //static const JoyStickState getJoyStickState(unsigned int ID);
     108
     109        static void setWindowExtents(const int width, const int height);
     110
     111        static void storeKeyStroke(const std::string& name);
     112        static void keyBind(const std::string& command);
     113
     114        static void calibrate();
     115
     116        static void tick(float dt);
     117
     118        static SimpleInputState*   createSimpleInputState  (const std::string& name, int priority);
     119        static ExtendedInputState* createExtendedInputState(const std::string& name, int priority);
     120        static bool destroyState (const std::string& name);
     121        //static bool removeState (const std::string& name);
     122        static InputState* getState       (const std::string& name);
     123        static InputState* getCurrentState();
     124        static bool requestEnterState     (const std::string& name);
     125        static bool requestLeaveState     (const std::string& name);
     126
     127    private: // functions
     128        // don't mess with a Singleton
     129        InputManager ();
     130        InputManager (const InputManager&);
     131        ~InputManager();
     132
     133        // Intenal methods
     134        bool _initialise(const size_t, int, int, bool, bool, bool);
     135        bool _initialiseKeyboard();
     136        bool _initialiseMouse();
     137        bool _initialiseJoySticks();
     138        void _redimensionLists();
     139
     140        void _destroy();
     141        void _destroyKeyboard();
     142        void _destroyMouse();
     143        void _destroyJoySticks();
     144        void _destroyState(InputState* state);
     145
     146        void _completeCalibration();
     147
     148        void _fireAxis(unsigned int iJoyStick, int axis, int value);
     149        unsigned int _getJoystick(const OIS::JoyStickEvent& arg);
     150
     151        void _tick(float dt);
     152
     153        void _updateActiveStates();
     154        bool _configureInputState(InputState* state, const std::string& name, int priority);
     155
     156        // input events
     157        bool mousePressed  (const OIS::MouseEvent    &arg, OIS::MouseButtonID id);
     158        bool mouseReleased (const OIS::MouseEvent    &arg, OIS::MouseButtonID id);
     159        bool mouseMoved    (const OIS::MouseEvent    &arg);
     160        bool keyPressed    (const OIS::KeyEvent      &arg);
     161        bool keyReleased   (const OIS::KeyEvent      &arg);
     162        bool buttonPressed (const OIS::JoyStickEvent &arg, int button);
     163        bool buttonReleased(const OIS::JoyStickEvent &arg, int button);
     164        bool axisMoved     (const OIS::JoyStickEvent &arg, int axis);
     165        bool sliderMoved   (const OIS::JoyStickEvent &arg, int id);
     166        bool povMoved      (const OIS::JoyStickEvent &arg, int id);
     167
     168        void setConfigValues();
     169
     170        static InputManager& _getInstance();
     171
     172    private: // variables
     173        OIS::InputManager*                          inputSystem_;     //!< OIS input manager
     174        OIS::Keyboard*                              keyboard_;        //!< OIS mouse
     175        OIS::Mouse*                                 mouse_;           //!< OIS keyboard
     176        std::vector<OIS::JoyStick*>                 joySticks_;       //!< OIS joy sticks
     177        unsigned int                                joySticksSize_;
     178        unsigned int                                devicesNum_;
     179
     180        // some internally handled states
     181        SimpleInputState*                                 stateDetector_;   //!< KeyDetector instance
     182        SimpleInputState*                                 stateCalibrator_;
     183        SimpleInputState*                                 stateEmpty_;
     184
     185        std::map<std::string, InputState*>          inputStatesByName_;
     186        std::map<int, InputState*>                  inputStatesByPriority_;
     187
     188        std::vector<InputState*> stateEnterRequests_;                  //!< Request to enter a new state
     189        std::vector<InputState*> stateLeaveRequests_;                    //!< Request to leave the current state
     190
     191        std::map<int, InputState*> activeStates_;
     192        std::vector<InputState*>   activeStatesTop_;    //!< Current input states for joy stick events.
     193        std::vector<InputState*>   activeStatesTicked_;    //!< Current input states for joy stick events.
     194
     195        // joystick calibration
     196        //std::vector<int> marginalsMaxConfig_;
     197        //std::vector<int> marginalsMinConfig_;
     198        int marginalsMax_[24];
     199        int marginalsMin_[24];
     200        bool bCalibrated_;
     201        bool bCalibrating_;
     202
     203        unsigned int keyboardModifiers_;           //!< Bit mask representing keyboard modifiers
     204        //! Keeps track of the joy stick POV states
     205        std::vector<POVStates>                      povStates_;
     206        //! Keeps track of the possibly two slider axes
     207        std::vector<SliderStates>                   sliderStates_;
     208        std::vector<JoyStickCalibration>            joySticksCalibration_;
     209
     210        std::vector<Key>                            keysDown_;
     211        std::vector<MouseButton::Enum>              mouseButtonsDown_;
     212        std::vector<std::vector<int> >              joyStickButtonsDown_;
     213
     214        static std::string                          bindingCommmandString_s;
     215    };
    258216
    259217}
Note: See TracChangeset for help on using the changeset viewer.