Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/gui/src/core/input/ExtendedInputState.cc @ 2909

Last change on this file since 2909 was 2800, checked in by rgrieder, 16 years ago

Renaming "tick" to "update" for all those classes not inheriting from Tickable to avoid confusions.
GameState::ticked still exists, but that's going to change anyway.

  • Property svn:eol-style set to native
File size: 14.1 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/**
30@file
31@brief
32    Implementation of the ExtendedInputState class.
33*/
34
35#include "ExtendedInputState.h"
36
37#include <cassert>
38#include "util/Debug.h"
39
40namespace orxonox
41{
42    using namespace InputDevice;
43
44    void ExtendedInputState::numberOfJoySticksChanged(unsigned int n)
45    {
46        unsigned int oldSize = joyStickHandlers_.size();
47        joyStickHandlers_.resize(n);
48
49        if (oldSize > n)
50        {
51            // we have to add all the handlers in joyStickHandlersAll_ to the joyStickHandlers_[>n]
52            for (unsigned int j = 0; j < joyStickHandlersAll_.size(); ++j)
53            {
54                for (unsigned int i = oldSize; i < n; ++i)
55                {
56                    joyStickHandlers_[i].push_back(joyStickHandlersAll_[j]);
57                }
58            }
59        }
60        update();
61    }
62
63    void ExtendedInputState::keyPressed(const KeyEvent& evt)
64    {
65        for (unsigned int i = 0; i < keyHandlers_.size(); i++)
66            keyHandlers_[i]->keyPressed(evt);
67    }
68
69    void ExtendedInputState::keyReleased(const KeyEvent& evt)
70    {
71        for (unsigned int i = 0; i < keyHandlers_.size(); i++)
72            keyHandlers_[i]->keyReleased(evt);
73    }
74
75    void ExtendedInputState::keyHeld(const KeyEvent& evt)
76    {
77        for (unsigned int i = 0; i < keyHandlers_.size(); i++)
78            keyHandlers_[i]->keyHeld(evt);
79    }
80
81
82    void ExtendedInputState::mouseMoved(IntVector2 abs, IntVector2 rel, IntVector2 clippingSize)
83    {
84        for (unsigned int i = 0; i < mouseHandlers_.size(); i++)
85            mouseHandlers_[i]->mouseMoved(abs, rel, clippingSize);
86    }
87
88    void ExtendedInputState::mouseScrolled(int abs, int rel)
89    {
90        for (unsigned int i = 0; i < mouseHandlers_.size(); i++)
91            mouseHandlers_[i]->mouseScrolled(abs, rel);
92    }
93
94    void ExtendedInputState::mouseButtonPressed(MouseButtonCode::ByEnum id)
95    {
96        for (unsigned int i = 0; i < mouseHandlers_.size(); i++)
97            mouseHandlers_[i]->mouseButtonPressed(id);
98    }
99
100    void ExtendedInputState::mouseButtonReleased(MouseButtonCode::ByEnum id)
101    {
102        for (unsigned int i = 0; i < mouseHandlers_.size(); i++)
103            mouseHandlers_[i]->mouseButtonReleased(id);
104    }
105
106    void ExtendedInputState::mouseButtonHeld(MouseButtonCode::ByEnum id)
107    {
108        for (unsigned int i = 0; i < mouseHandlers_.size(); i++)
109            mouseHandlers_[i]->mouseButtonHeld(id);
110    }
111
112
113    void ExtendedInputState::joyStickAxisMoved(unsigned int joyStickID, unsigned int axis, float value)
114    {
115        assert(joyStickID < joyStickHandlers_.size());
116        for (unsigned int i = 0; i < joyStickHandlers_[joyStickID].size(); i++)
117            joyStickHandlers_[joyStickID][i]->joyStickAxisMoved(joyStickID, axis, value);
118    }
119
120    void ExtendedInputState::joyStickButtonPressed(unsigned int joyStickID, JoyStickButtonCode::ByEnum id)
121    {
122        assert(joyStickID < joyStickHandlers_.size());
123        for (unsigned int i = 0; i < joyStickHandlers_[joyStickID].size(); i++)
124            joyStickHandlers_[joyStickID][i]->joyStickButtonPressed(joyStickID, id);
125    }
126
127    void ExtendedInputState::joyStickButtonReleased(unsigned int joyStickID, JoyStickButtonCode::ByEnum id)
128    {
129        assert(joyStickID < joyStickHandlers_.size());
130        for (unsigned int i = 0; i < joyStickHandlers_[joyStickID].size(); i++)
131            joyStickHandlers_[joyStickID][i]->joyStickButtonReleased(joyStickID, id);
132    }
133
134    void ExtendedInputState::joyStickButtonHeld(unsigned int joyStickID, JoyStickButtonCode::ByEnum id)
135    {
136        assert(joyStickID < joyStickHandlers_.size());
137        for (unsigned int i = 0; i < joyStickHandlers_[joyStickID].size(); i++)
138            joyStickHandlers_[joyStickID][i]->joyStickButtonHeld(joyStickID, id);
139    }
140
141
142    /**
143    @brief
144        Adds a key handler.
145    @param handler
146        Pointer to the handler object.
147    @return
148        True if added, false if handler already existed.
149    */
150    bool ExtendedInputState::addKeyHandler(KeyHandler* handler)
151    {
152        if (!handler)
153            return false;
154
155        // see whether the handler already is in the list
156        for (std::vector<KeyHandler*>::iterator it = keyHandlers_.begin(); it != keyHandlers_.end(); it++)
157        {
158            if ((*it) == handler)
159            {
160                return false;
161            }
162        }
163        keyHandlers_.push_back(handler);
164        update();
165        return true;
166    }
167
168    /**
169    @brief
170        Removes a Key handler from the state.
171    @param handler
172        Pointer to the handler.
173    @return
174        True if removal was successful, false if handler was not found.
175    */
176    bool ExtendedInputState::removeKeyHandler(KeyHandler* handler)
177    {
178        if (!handler)
179            return false;
180
181        for (std::vector<KeyHandler*>::iterator it = keyHandlers_.begin(); it != keyHandlers_.end(); it++)
182        {
183            if ((*it) == handler)
184            {
185                keyHandlers_.erase(it);
186                update();
187                return true;
188            }
189        }
190        return false;
191    }
192
193
194    /**
195    @brief
196        Adds a mouse handler.
197    @param handler
198        Pointer to the handler object.
199    @return
200        True if added, false if handler already existed.
201    */
202    bool ExtendedInputState::addMouseHandler(MouseHandler* handler)
203    {
204        if (!handler)
205            return false;
206
207        // see whether the handler already is in the list
208        for (std::vector<MouseHandler*>::iterator it = mouseHandlers_.begin(); it != mouseHandlers_.end(); it++)
209        {
210            if ((*it) == handler)
211            {
212                return false;
213            }
214        }
215        mouseHandlers_.push_back(handler);
216        update();
217        return true;
218    }
219
220    /**
221    @brief
222        Removes a mouse handler from the state.
223    @param handler
224        Pointer to the handler.
225    @return
226        True if removal was successful, false if handler was not found.
227    */
228    bool ExtendedInputState::removeMouseHandler(MouseHandler* handler)
229    {
230        if (!handler)
231            return false;
232
233        for (std::vector<MouseHandler*>::iterator it = mouseHandlers_.begin(); it != mouseHandlers_.end(); it++)
234        {
235            if ((*it) == handler)
236            {
237                mouseHandlers_.erase(it);
238                update();
239                return true;
240            }
241        }
242        return false;
243    }
244
245
246    /**
247    @brief
248        Adds a joy stick handler.
249    @param handler
250        Pointer to the handler object.
251    @param joyStickID
252        ID of the joy stick
253    @return
254        True if added, false if handler already existed.
255    */
256    bool ExtendedInputState::addJoyStickHandler(JoyStickHandler* handler, unsigned int joyStickID)
257    {
258        if (!handler || joyStickID >= joyStickHandlers_.size())
259            return false;
260
261        // see whether the handler already is in the list
262        for (std::vector<JoyStickHandler*>::iterator it = joyStickHandlers_[joyStickID].begin();
263            it != joyStickHandlers_[joyStickID].end(); it++)
264        {
265            if ((*it) == handler)
266            {
267                return false;
268            }
269        }
270        joyStickHandlers_[joyStickID].push_back(handler);
271        update();
272        return true;
273    }
274
275    /**
276    @brief
277        Removes a joy stick handler from the state.
278    @param handler
279        Pointer to the handler.
280    @param joyStickID
281        ID of the joy stick
282    @return
283        True if removal was successful, false if handler was not found.
284    */
285    bool ExtendedInputState::removeJoyStickHandler(JoyStickHandler* handler, unsigned int joyStickID)
286    {
287        if (!handler || joyStickID >= joyStickHandlers_.size())
288            return false;
289
290        // remove it from the list of all-joystick handlers if present
291        for (std::vector<JoyStickHandler*>::iterator it = joyStickHandlersAll_.begin();
292            it != joyStickHandlersAll_.end(); it++)
293        {
294            if ((*it) == handler)
295            {
296                joyStickHandlersAll_.erase(it);
297            }
298        }
299
300        // remove handler from the list of seperate lists of handlers
301        for (std::vector<JoyStickHandler*>::iterator it = joyStickHandlers_[joyStickID].begin();
302            it != joyStickHandlers_[joyStickID].end(); it++)
303        {
304            if ((*it) == handler)
305            {
306                joyStickHandlers_[joyStickID].erase(it);
307                update();
308                return true;
309            }
310        }
311        return false;
312    }
313
314    /**
315    @brief
316        Adds a joy stick handler.
317    @param handler
318        Pointer to the handler object.
319    @return
320        True if added, false if handler already existed.
321    */
322    bool ExtendedInputState::addJoyStickHandler(JoyStickHandler* handler)
323    {
324        if (!handler)
325            return false;
326
327        // see whether the handler already is in the big list
328        for (std::vector<JoyStickHandler*>::iterator it = joyStickHandlersAll_.begin();
329            it != joyStickHandlersAll_.end(); it++)
330        {
331            if ((*it) == handler)
332            {
333                return false;
334            }
335        }
336        joyStickHandlersAll_.push_back(handler);
337        update();
338
339        // now, we have to add it to all the separate lists
340        for (unsigned int iJoyStick = 0; iJoyStick < joyStickHandlers_.size(); ++iJoyStick)
341            addJoyStickHandler(handler, iJoyStick);
342        return true;
343    }
344
345    /**
346    @brief
347        Removes a joy stick handler from the state.
348    @param handler
349        Pointer to the handler.
350    @return
351        True if removal was successful, false if handler was not found.
352    */
353    bool ExtendedInputState::removeJoyStickHandler(JoyStickHandler* handler)
354    {
355        if (!handler)
356            return false;
357
358        bool success = false;
359        // remove from all lists in a loop (also removes it from the big list)
360        for (unsigned int iJoyStick = 0; iJoyStick < joyStickHandlers_.size(); ++iJoyStick)
361            success |= removeJoyStickHandler(handler, iJoyStick);
362
363        return success;
364    }
365
366    /**
367    @brief
368        Adds a handler of any kind. dynamic_cast determines to which list it is added.
369    @param handler
370        Pointer to the handler object.
371    @return
372        True if added, false if handler already existed.
373    */
374    bool ExtendedInputState::addHandler(InputHandler* handler)
375    {
376        bool success = false;
377
378        success |= addKeyHandler(dynamic_cast<KeyHandler*>(handler));
379        success |= addMouseHandler(dynamic_cast<MouseHandler*>(handler));
380        success |= addJoyStickHandler(dynamic_cast<JoyStickHandler*>(handler));
381
382        return success;
383    }
384
385    /**
386    @brief
387        Removes a handler from all lists.
388    @param handler
389        Pointer to the handler.
390    @return
391        True if removal was successful, false if handler was not found.
392    */
393    bool ExtendedInputState::removeHandler(InputHandler* handler)
394    {
395        bool success = false;
396
397        success |= removeKeyHandler(dynamic_cast<KeyHandler*>(handler));
398        success |= removeMouseHandler(dynamic_cast<MouseHandler*>(handler));
399        success |= removeJoyStickHandler(dynamic_cast<JoyStickHandler*>(handler));
400
401        return success;
402    }
403
404    void ExtendedInputState::updateInput(float dt)
405    {
406        for (unsigned int i = 0; i < allHandlers_.size(); ++i)
407        {
408            allHandlers_[i]->updateInput(dt);
409        }
410    }
411
412    void ExtendedInputState::updateInput(float dt, unsigned int device)
413    {
414        switch (device)
415        {
416        case Keyboard:
417            for (unsigned int i = 0; i < keyHandlers_.size(); ++i)
418                keyHandlers_[i]->updateKey(dt);
419            break;
420
421        case Mouse:
422            for (unsigned int i = 0; i < mouseHandlers_.size(); ++i)
423                mouseHandlers_[i]->updateMouse(dt);
424            break;
425
426        default: // joy sticks
427            for (unsigned int i = 0; i < joyStickHandlers_[device - 2].size(); ++i)
428                joyStickHandlers_[device - 2][i]->updateJoyStick(dt, device - 2);
429            break;
430        }
431    }
432
433    void ExtendedInputState::update()
434    {
435        // we can use a set to have a list of unique pointers (an object can implement all 3 handlers)
436        std::set<InputHandler*> tempSet;
437        for (unsigned int iHandler = 0; iHandler < keyHandlers_.size(); iHandler++)
438            tempSet.insert(keyHandlers_[iHandler]);
439        for (unsigned int iHandler = 0; iHandler < mouseHandlers_.size(); iHandler++)
440            tempSet.insert(mouseHandlers_[iHandler]);
441        for (unsigned int iJoyStick = 0; iJoyStick < joyStickHandlers_.size(); iJoyStick++)
442            for (unsigned int iHandler = 0; iHandler < joyStickHandlers_[iJoyStick].size(); iHandler++)
443                tempSet.insert(joyStickHandlers_[iJoyStick][iHandler]);
444
445        // copy the content of the map back to the actual vector
446        allHandlers_.clear();
447        for (std::set<InputHandler*>::const_iterator itHandler = tempSet.begin();
448            itHandler != tempSet.end(); itHandler++)
449            allHandlers_.push_back(*itHandler);
450
451        // update the deviceEnabled options
452        setInputDeviceEnabled(Keyboard, (keyHandlers_.size() != 0));
453        setInputDeviceEnabled(Mouse, (mouseHandlers_.size() != 0));
454        for (unsigned int i = 0; i < joyStickHandlers_.size(); ++i)
455            setInputDeviceEnabled(2 + i, (joyStickHandlers_[i].size() != 0));
456
457        this->bHandlersChanged_ = true;
458    }
459}
Note: See TracBrowser for help on using the repository browser.