Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/levelElias/src/libraries/core/input/KeyBinder.h @ 10061

Last change on this file since 10061 was 7861, checked in by landauf, 14 years ago

added function to KeyBinder which allows to change the keybind mode (OnPress, OnRelease, OnHold) of a command which is bound to a key.
enhanced ConsoleCommand (+Manipulator) to use this feature.

input system experts, please review :D

  • Property svn:eol-style set to native
File size: 9.5 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
23 *      Reto Grieder
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29#ifndef _KeyBinder_H__
30#define _KeyBinder_H__
31
32#include "InputPrereqs.h"
33
34#include <cassert>
35#include <string>
36#include <vector>
37#include <map>
38#include <boost/shared_ptr.hpp>
39
40#include "InputHandler.h"
41#include "Button.h"
42#include "HalfAxis.h"
43#include "InputCommands.h"
44#include "JoyStickQuantityListener.h"
45
46// tolua_begin
47namespace orxonox
48{
49    // tolua_end
50    /**
51    @brief
52        Maps mouse, keyboard and joy stick input to command strings and executes them.
53
54        The bindings are stored in ini-files (like the one for configValues) in the config Path.
55    @remarks
56        You cannot change the filename because the KeyBinderManager maps these filenames to the
57        KeyBinders. If you need to load other bindings, just create a new one.
58    */
59    class _CoreExport KeyBinder // tolua_export
60        : public InputHandler, public JoyStickQuantityListener
61    { // tolua_export
62    public:
63        KeyBinder (const std::string& filename);
64        virtual ~KeyBinder();
65
66        void clearBindings();
67        bool setBinding(const std::string& binding, const std::string& name, bool bTemporary = false);
68        const std::string& getBinding(const std::string& commandName); //tolua_export
69        const std::string& getBinding(const std::string& commandName, unsigned int index); //tolua_export
70        unsigned int getNumberOfBindings(const std::string& commandName); //tolua_export
71
72        const std::string& getBindingsFilename()
73            { return this->filename_; }
74        void setConfigValues();
75        void resetJoyStickAxes();
76        void resetMouseAxes();
77
78        void changeMode(ConsoleCommand* command, KeybindMode::Value mode);
79
80    protected: // functions
81        void loadBindings();
82        void buttonThresholdChanged();
83        void initialiseJoyStickBindings();
84        void compilePointerLists();
85        // from JoyStickQuantityListener interface
86        virtual void JoyStickQuantityChanged(const std::vector<JoyStick*>& joyStickList);
87
88        void allDevicesUpdated(float dt);
89        void mouseUpdated(float dt);
90        void joyStickUpdated(unsigned int joyStick, float dt);
91        // internal
92        void tickHalfAxis(HalfAxis& halfAxis);
93
94        void buttonPressed (const KeyEvent& evt);
95        void buttonReleased(const KeyEvent& evt);
96        void buttonHeld    (const KeyEvent& evt);
97
98        void buttonPressed (MouseButtonCode::ByEnum button);
99        void buttonReleased(MouseButtonCode::ByEnum button);
100        void buttonHeld    (MouseButtonCode::ByEnum button);
101        void mouseMoved    (IntVector2 abs, IntVector2 rel, IntVector2 clippingSize);
102        void mouseScrolled (int abs, int rel);
103
104        void buttonPressed (unsigned int device, JoyStickButtonCode::ByEnum button);
105        void buttonReleased(unsigned int device, JoyStickButtonCode::ByEnum button);
106        void buttonHeld    (unsigned int device, JoyStickButtonCode::ByEnum button);
107        void axisMoved     (unsigned int device, unsigned int axis, float value);
108
109    protected: // variables
110        //! Currently active joy sticks
111        std::vector<JoyStick*>  joySticks_;
112
113        //! Actual key bindings for keys on the keyboard
114        Button keys_            [KeyCode::numberOfKeys];
115        //! Number of mouse buttons in KeyBinder (+4)
116        static const unsigned int numberOfMouseButtons_ = MouseButtonCode::numberOfButtons + 4;
117        //! Actual key bindings for mouse buttons including the wheel(s)
118        Button mouseButtons_    [numberOfMouseButtons_];
119        //! Actual key bindings for mouse axes
120        HalfAxis mouseAxes_     [MouseAxisCode::numberOfAxes * 2];
121
122        //! Helper class to use something like std:vector<Button[64]>
123        struct JoyStickButtonVector
124        {
125            Button& operator[](unsigned int index) { return buttons[index]; }
126            Button buttons[JoyStickButtonCode::numberOfButtons];
127        };
128        //! Actual key bindings for joy stick buttons
129        std::vector<shared_ptr<JoyStickButtonVector> > joyStickButtons_;
130        //! Helper class to use something like std:vector<HalfAxis[48]>
131        struct JoyStickAxisVector
132        {
133            HalfAxis& operator[](unsigned int index) { return halfAxes[index]; }
134            HalfAxis halfAxes[JoyStickAxisCode::numberOfAxes * 2];
135        };
136        //! Actual key bindings for joy stick axes (and sliders)
137        std::vector<shared_ptr<JoyStickAxisVector> > joyStickAxes_;
138
139        //! Pointer map with all Buttons, including half axes
140        std::map<std::string, Button*> allButtons_;
141        //! Pointer list with all half axes
142        std::vector<HalfAxis*> allHalfAxes_;
143        //! Maps input commands to all Button names, including half axes
144        std::map< std::string, std::vector<std::string> > allCommands_;
145
146        /**
147        @brief
148            Commands that have additional parameters (axes) are executed at the end of
149            update() so that all values can be buffered for single execution.
150        */
151        std::vector<BufferedParamCommand*> paramCommandBuffer_;
152
153        //! Keeps track of the absolute mouse value
154        float mousePosition_[2];
155        //! Used to derive mouse input if requested
156        int mouseRelative_[2];
157        float deriveTime_;
158
159        //! Name of the file used in this KeyBinder (constant!)
160        const std::string filename_;
161        //! Config file used. NULL in case of KeyDetector. Also indicates whether we've already loaded.
162        ConfigFile* configFile_;
163        //! Config file from the data directory that only serves as fallback
164        ConfigFile* fallbackConfigFile_;
165
166    private:
167        void addButtonToCommand(const std::string& command, Button* button);
168
169        //##### ConfigValues #####
170        //! Whether to filter small value analog input
171        bool bFilterAnalogNoise_;
172        //! Threshold for analog triggers until which the state is 0.
173        float analogThreshold_;
174        //! Threshold for analog triggers until which the button is not pressed.
175        float buttonThreshold_;
176        //! Derive mouse input for absolute values?
177        bool bDeriveMouseInput_;
178        //! Accuracy of the mouse input deriver. The higher the more precise, but laggier.
179        float derivePeriod_;
180        //! mouse sensitivity
181        float mouseSensitivity_;
182        //! mouse sensitivity if mouse input is derived
183        float mouseSensitivityDerived_;
184        //! Equals one step of the mouse wheel
185        int mouseWheelStepSize_;
186
187        //! Multiplication of mouse sensitivity and clipping size
188        float totalMouseSensitivity_;
189
190        //##### Constant config variables #####
191        // Use some value at about 1000. This can be configured with mouseSensitivity_ anyway.
192        static const int mouseClippingSize_ = 1024;
193    };// tolua_export
194
195
196    inline void KeyBinder::buttonPressed (const KeyEvent& evt)
197    { assert(!keys_[evt.getKeyCode()].name_.empty()); keys_[evt.getKeyCode()].execute(KeybindMode::OnPress); }
198
199    inline void KeyBinder::buttonReleased(const KeyEvent& evt)
200    { assert(!keys_[evt.getKeyCode()].name_.empty()); keys_[evt.getKeyCode()].execute(KeybindMode::OnRelease); }
201
202    inline void KeyBinder::buttonHeld    (const KeyEvent& evt)
203    { assert(!keys_[evt.getKeyCode()].name_.empty()); keys_[evt.getKeyCode()].execute(KeybindMode::OnHold); }
204
205
206    inline void KeyBinder::buttonPressed (MouseButtonCode::ByEnum button)
207    { mouseButtons_[button].execute(KeybindMode::OnPress); }
208
209    inline void KeyBinder::buttonReleased(MouseButtonCode::ByEnum button)
210    { mouseButtons_[button].execute(KeybindMode::OnRelease); }
211
212    inline void KeyBinder::buttonHeld    (MouseButtonCode::ByEnum button)
213    { mouseButtons_[button].execute(KeybindMode::OnHold); }
214
215
216    inline void KeyBinder::buttonPressed (unsigned int device, JoyStickButtonCode::ByEnum button)
217    { (*joyStickButtons_[device])[button].execute(KeybindMode::OnPress); }
218
219    inline void KeyBinder::buttonReleased(unsigned int device, JoyStickButtonCode::ByEnum button)
220    { (*joyStickButtons_[device])[button].execute(KeybindMode::OnRelease); }
221
222    inline void KeyBinder::buttonHeld    (unsigned int device, JoyStickButtonCode::ByEnum button)
223    { (*joyStickButtons_[device])[button].execute(KeybindMode::OnHold); }
224
225    inline void KeyBinder::allDevicesUpdated(float dt)
226    {
227        // execute all buffered bindings (additional parameter)
228        for (unsigned int i = 0; i < paramCommandBuffer_.size(); i++)
229        {
230            paramCommandBuffer_[i]->rel_ *= dt;
231            paramCommandBuffer_[i]->execute();
232        }
233
234        // always reset the relative movement of the mouse
235        for (unsigned int i = 0; i < MouseAxisCode::numberOfAxes * 2; i++)
236            mouseAxes_[i].relVal_ = 0.0f;
237    }
238}// tolua_export
239
240#endif /* _KeyBinder_H__ */
Note: See TracBrowser for help on using the repository browser.