source: code/branches/input/src/core/input/InputManager.h @ 1630

/*
 *   ORXONOX - the hottest 3D action shooter ever to exist
 *                    > www.orxonox.net <
 *
 *
 *   License notice:
 *
 *   This program is free software; you can redistribute it and/or
 *   modify it under the terms of the GNU General Public License
 *   as published by the Free Software Foundation; either version 2
 *   of the License, or (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
 *
 *   Author:
 *      Reto Grieder
 *   Co-authors:
 *      ...
 *
 */

/**
@file
@brief
    Implementation of a little Input handler that distributes everything
    coming from OIS.
*/

#ifndef _InputManager_H__
#define _InputManager_H__

#include "core/CorePrereqs.h"

#include <map>
#include <vector>
#include "util/Math.h"
#include "core/OrxonoxClass.h"
#include "InputInterfaces.h"

namespace orxonox
{
    /**
    @brief
        Helper class to realise a vector<int[4]>
    */
    class POVStates
    {
    public:
        int operator[](unsigned int index) { return povStates[index]; }
        int povStates[4];
    };

    /**
    @brief
        Helper class to realise a vector< {int[4], int[4]} >
    */
    class SliderStates
    {
    public:
        IntVector2 sliderStates[4];
    };

    /**
    @brief
        Struct for storing a custom input state
    */
    struct StoredState
    {
        std::vector<KeyHandler*>                    activeKeyHandlers_;
        std::vector<MouseHandler*>                  activeMouseHandlers_;
        std::vector<std::vector<JoyStickHandler*> > activeJoyStickHandlers_;
        std::vector<std::pair<InputTickable*, HandlerState> > activeHandlers_;
    };

    struct JoyStickCalibration
    {
        int zeroStates[24];
        float positiveCoeff[24];
        float negativeCoeff[24];
    };

    /**
    @brief
        Captures and distributes mouse and keyboard input.
    */
    class _CoreExport InputManager
        : public OrxonoxClass,
        public OIS::KeyListener, public OIS::MouseListener, public OIS::JoyStickListener
    {
    public: // enumerations
        /**
        @brief
            Designates the way input is handled and redirected.
        */
        enum InputState
        {
            IS_UNINIT,    //!< InputManager has not yet been initialised.
            IS_NONE,      //!< Input is discarded.
            IS_NORMAL,    //!< Normal play state. Key and button bindings are active.
            IS_GUI,       //!< All OIS input events are passed to CEGUI.
            IS_CONSOLE,   //!< Keyboard input is redirected to the InputBuffer.
            IS_DETECT,    //!< All the input additionally goes to the KeyDetector
            IS_NODETECT,  //!< remove KeyDetector
            IS_NOCALIBRATE,
            IS_CALIBRATE,
            IS_CUSTOM     //!< Any possible configuration.
        };

    public: // member functions
        void setConfigValues();

    public: // static functions
        static bool initialise(const size_t windowHnd, int windowWidth, int windowHeight,
                               bool createKeyboard = true, bool createMouse = true, bool createJoySticks = false);
        static bool initialiseKeyboard();
        static bool initialiseMouse();
        static bool initialiseJoySticks();
        static int  numberOfKeyboards();
        static int  numberOfMice();
        static int  numberOfJoySticks();

        static void destroy();
        static void destroyKeyboard();
        static void destroyMouse();
        static void destroyJoySticks();

        //static bool isModifierDown(KeyboardModifier::Enum modifier);
        //static bool isKeyDown(KeyCode::Enum key);
        //static const MouseState getMouseState();
        //static const JoyStickState getJoyStickState(unsigned int ID);

        static void setWindowExtents(const int width, const int height);

        static void setInputState(const InputState state);
        static InputState getInputState();

        static void storeKeyStroke(const std::string& name);
        static void keyBind(const std::string& command);

        static void calibrate();

        static void tick(float dt);

        static bool addKeyHandler                 (KeyHandler* handler, const std::string& name);
        static bool removeKeyHandler              (const std::string& name);
        static KeyHandler* getKeyHandler          (const std::string& name);
        static bool enableKeyHandler              (const std::string& name);
        static bool disableKeyHandler             (const std::string& name);
        static bool isKeyHandlerActive            (const std::string& name);

        static bool addMouseHandler               (MouseHandler* handler, const std::string& name);
        static bool removeMouseHandler            (const std::string& name);
        static MouseHandler* getMouseHandler      (const std::string& name);
        static bool enableMouseHandler            (const std::string& name);
        static bool disableMouseHandler           (const std::string& name);
        static bool isMouseHandlerActive          (const std::string& name);

        static bool addJoyStickHandler            (JoyStickHandler* handler, const std::string& name);
        static bool removeJoyStickHandler         (const std::string& name);
        static JoyStickHandler* getJoyStickHandler(const std::string& name);
        static bool enableJoyStickHandler         (const std::string& name, unsigned int id);
        static bool disableJoyStickHandler        (const std::string& name, unsigned int id);
        static bool isJoyStickHandlerActive       (const std::string& name, unsigned int id);

    private: // functions
        // don't mess with a Singleton
        InputManager ();
        InputManager (const InputManager&);
        ~InputManager();

        // Intenal methods
        bool _initialise(const size_t, int, int, bool, bool, bool);
        bool _initialiseKeyboard();
        bool _initialiseMouse();
        bool _initialiseJoySticks();

        void _destroy();
        void _destroyKeyboard();
        void _destroyMouse();
        void _destroyJoySticks();

        void _updateTickables();

        void _saveState();
        void _restoreState();

        void _completeCalibration();

        void _fireAxis(unsigned int iJoyStick, int axis, int value);
        unsigned int _getJoystick(const OIS::JoyStickEvent& arg);

        void _tick(float dt);

        // input events
        bool mousePressed  (const OIS::MouseEvent    &arg, OIS::MouseButtonID id);
        bool mouseReleased (const OIS::MouseEvent    &arg, OIS::MouseButtonID id);
        bool mouseMoved    (const OIS::MouseEvent    &arg);
        bool keyPressed    (const OIS::KeyEvent      &arg);
        bool keyReleased   (const OIS::KeyEvent      &arg);
        bool buttonPressed (const OIS::JoyStickEvent &arg, int button);
        bool buttonReleased(const OIS::JoyStickEvent &arg, int button);
        bool axisMoved     (const OIS::JoyStickEvent &arg, int axis);
        bool sliderMoved   (const OIS::JoyStickEvent &arg, int id);
        bool povMoved      (const OIS::JoyStickEvent &arg, int id);
        //bool vector3Moved  (const OIS::JoyStickEvent &arg, int id);

        static InputManager& _getSingleton();
        static InputManager* _getSingletonPtr() { return &_getSingleton(); }

    private: // variables
        OIS::InputManager*                          inputSystem_;     //!< OIS input manager
        OIS::Keyboard*                              keyboard_;        //!< OIS mouse
        OIS::Mouse*                                 mouse_;           //!< OIS keyboard
        std::vector<OIS::JoyStick*>                 joySticks_;       //!< OIS joy sticks
        unsigned int                                joySticksSize_;

        KeyBinder*                                  keyBinder_;       //!< KeyBinder instance
        KeyDetector*                                keyDetector_;     //!< KeyDetector instance
        InputBuffer*                                buffer_;          //!< InputBuffer instance
        CalibratorCallback*                         calibratorCallback_;

        InputState state_;
        InputState stateRequest_;
        InputState savedState_;
        unsigned int keyboardModifiers_;
        StoredState savedHandlers_;

        // joystick calibration
        //std::vector<int> marginalsMaxConfig_;
        //std::vector<int> marginalsMinConfig_;
        int marginalsMax_[24];
        int marginalsMin_[24];
        bool bCalibrated_;

        //! Keeps track of the joy stick POV states
        std::vector<POVStates>                      povStates_;
        //! Keeps track of the possibly two slider axes
        std::vector<SliderStates>                   sliderStates_;
        std::vector<JoyStickCalibration>            joySticksCalibration_;

        std::map<std::string, KeyHandler*>          keyHandlers_;
        std::map<std::string, MouseHandler*>        mouseHandlers_;
        std::map<std::string, JoyStickHandler*>     joyStickHandlers_;

        std::vector<KeyHandler*>                    activeKeyHandlers_;
        std::vector<MouseHandler*>                  activeMouseHandlers_;
        std::vector<std::vector<JoyStickHandler*> > activeJoyStickHandlers_;
        std::vector<std::pair<InputTickable*, HandlerState> > activeHandlers_;

        std::vector<Key>                            keysDown_;
        std::vector<MouseButton::Enum>              mouseButtonsDown_;
        std::vector<std::vector<int> >              joyStickButtonsDown_;

        static std::string                          bindingCommmandString_s;
    };

}

#endif /* _InputManager_H__ */