Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/trunk/src/core/input/InputManager.cc @ 3458

Last change on this file since 3458 was 3370, checked in by rgrieder, 15 years ago

Merged resource branch back to the trunk. Changes:

  • Automated graphics loading by evaluating whether a GameState requires it
  • Using native Tcl library (x3n)

Windows users: Update your dependency package!

  • Property svn:eol-style set to native
File size: 24.9 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 InputManager and a static variable from the InputHandler.
33*/
34
35#include "InputManager.h"
36
37#include <cassert>
38#include <climits>
39#include <ois/OISException.h>
40#include <ois/OISInputManager.h>
41#include <boost/foreach.hpp>
42
43#include "util/Exception.h"
44#include "util/ScopeGuard.h"
45#include "core/Clock.h"
46#include "core/CoreIncludes.h"
47#include "core/ConfigValueIncludes.h"
48#include "core/ConsoleCommand.h"
49#include "core/CommandLine.h"
50#include "core/Functor.h"
51
52#include "InputBuffer.h"
53#include "KeyDetector.h"
54#include "JoyStick.h"
55#include "JoyStickQuantityListener.h"
56#include "Mouse.h"
57#include "Keyboard.h"
58
59namespace orxonox
60{
61    SetCommandLineSwitch(keyboard_no_grab).information("Whether not to exclusively grab the keyboard");
62
63    // Abuse of this source file for the InputHandler
64    InputHandler InputHandler::EMPTY;
65
66    InputManager* InputManager::singletonPtr_s = 0;
67
68    //! Defines the |= operator for easier use.
69    inline InputManager::State operator|=(InputManager::State& lval, InputManager::State rval)
70    {
71        return (lval = (InputManager::State)(lval | rval));
72    }
73
74    //! Defines the &= operator for easier use.
75    inline InputManager::State operator&=(InputManager::State& lval, int rval)
76    {
77        return (lval = (InputManager::State)(lval & rval));
78    }
79
80    // ############################################################
81    // #####                  Initialisation                  #####
82    // ##########                                        ##########
83    // ############################################################
84    InputManager::InputManager(size_t windowHnd)
85        : internalState_(Bad)
86        , oisInputManager_(0)
87        , devices_(2)
88        , windowHnd_(0)
89        , emptyState_(0)
90        , keyDetector_(0)
91        , calibratorCallbackHandler_(0)
92    {
93        RegisterRootObject(InputManager);
94
95        CCOUT(4) << "Constructing..." << std::endl;
96
97        this->setConfigValues();
98
99        this->loadDevices(windowHnd);
100
101        // Lowest priority empty InputState
102        emptyState_ = createInputState("empty", false, false, InputStatePriority::Empty);
103        emptyState_->setHandler(&InputHandler::EMPTY);
104        activeStates_[emptyState_->getPriority()] = emptyState_;
105
106        // KeyDetector to evaluate a pressed key's name
107        InputState* detector = createInputState("detector", false, false, InputStatePriority::Detector);
108        // Create a callback to avoid buttonHeld events after the key has been detected
109        FunctorMember<InputManager>* bufferFunctor = createFunctor(&InputManager::clearBuffers);
110        bufferFunctor->setObject(this);
111        detector->setLeaveFunctor(bufferFunctor);
112        keyDetector_ = new KeyDetector();
113        detector->setHandler(keyDetector_);
114
115        // Joy stick calibration helper callback
116        InputState* calibrator = createInputState("calibrator", false, false, InputStatePriority::Calibrator);
117        calibrator->setHandler(&InputHandler::EMPTY);
118        calibratorCallbackHandler_ = new InputBuffer();
119        calibratorCallbackHandler_->registerListener(this, &InputManager::stopCalibration, '\r', true);
120        calibrator->setKeyHandler(calibratorCallbackHandler_);
121
122        this->updateActiveStates();
123
124        {
125            // calibrate console command
126            FunctorMember<InputManager>* functor = createFunctor(&InputManager::calibrate);
127            functor->setObject(this);
128            this->getIdentifier()->addConsoleCommand(createConsoleCommand(functor, "calibrate"), true);
129        }
130        {
131            // reload console command
132            FunctorMember<InputManager>* functor = createFunctor(&InputManager::reload);
133            functor->setObject(this);
134            this->getIdentifier()->addConsoleCommand(createConsoleCommand(functor, "reload"), false);
135        }
136
137        CCOUT(4) << "Construction complete." << std::endl;
138        internalState_ = Nothing;
139    }
140
141    void InputManager::setConfigValues()
142    {
143    }
144
145    /**
146    @brief
147        Creates the OIS::InputMananger, the keyboard, the mouse and
148        the joys ticks. If either of the first two fail, this method throws an exception.
149    @param windowHnd
150        The window handle of the render window
151    @param windowWidth
152        The width of the render window
153    @param windowHeight
154        The height of the render window
155    */
156    void InputManager::loadDevices(size_t windowHnd)
157    {
158        CCOUT(3) << "Loading input devices..." << std::endl;
159
160        // When loading the devices they should not already be loaded
161        assert(internalState_ & Bad);
162        assert(devices_[InputDeviceEnumerator::Mouse] == 0);
163        assert(devices_[InputDeviceEnumerator::Keyboard] == 0);
164        assert(devices_.size() == InputDeviceEnumerator::FirstJoyStick);
165
166        // store handle internally so we can reload OIS
167        windowHnd_ = windowHnd;
168
169        OIS::ParamList paramList;
170        std::ostringstream windowHndStr;
171
172        // Fill parameter list
173        windowHndStr << static_cast<unsigned int>(windowHnd);
174        paramList.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));
175#if defined(ORXONOX_PLATFORM_WINDOWS)
176        //paramList.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_NONEXCLUSIVE")));
177        //paramList.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_FOREGROUND")));
178        //paramList.insert(std::make_pair(std::string("w32_keyboard"), std::string("DISCL_NONEXCLUSIVE")));
179        //paramList.insert(std::make_pair(std::string("w32_keyboard"), std::string("DISCL_FOREGROUND")));
180#elif defined(ORXONOX_PLATFORM_LINUX)
181        paramList.insert(std::make_pair(std::string("XAutoRepeatOn"), std::string("true")));
182        paramList.insert(std::make_pair(std::string("x11_mouse_grab"), "true"));
183        paramList.insert(std::make_pair(std::string("x11_mouse_hide"), "true"));
184        bool kbNoGrab;
185        CommandLine::getValue("keyboard_no_grab", &kbNoGrab);
186        if (kbNoGrab)
187            paramList.insert(std::make_pair(std::string("x11_keyboard_grab"), std::string("false")));
188        else
189            paramList.insert(std::make_pair(std::string("x11_keyboard_grab"), std::string("true")));
190#endif
191
192        try
193        {
194            oisInputManager_ = OIS::InputManager::createInputSystem(paramList);
195            // Exception-safety
196            Loki::ScopeGuard guard = Loki::MakeGuard(OIS::InputManager::destroyInputSystem, oisInputManager_);
197            CCOUT(ORX_DEBUG) << "Created OIS input manager." << std::endl;
198
199            if (oisInputManager_->getNumberOfDevices(OIS::OISKeyboard) > 0)
200                devices_[InputDeviceEnumerator::Keyboard] = new Keyboard(InputDeviceEnumerator::Keyboard, oisInputManager_);
201            else
202                ThrowException(InitialisationFailed, "InputManager: No keyboard found, cannot proceed!");
203
204            // Successful initialisation
205            guard.Dismiss();
206        }
207        catch (const std::exception& ex)
208        {
209            oisInputManager_ = NULL;
210            internalState_ |= Bad;
211            ThrowException(InitialisationFailed, "Could not initialise the input system: " << ex.what());
212        }
213
214        // TODO: Remove the two parameters
215        this->loadMouse();
216        this->loadJoySticks();
217
218        // Reorder states in case some joy sticks were added/removed
219        this->updateActiveStates();
220
221        CCOUT(3) << "Input devices loaded." << std::endl;
222    }
223
224    //! Creates a new orxonox::Mouse
225    void InputManager::loadMouse()
226    {
227        if (oisInputManager_->getNumberOfDevices(OIS::OISMouse) > 0)
228        {
229            try
230            {
231                devices_[InputDeviceEnumerator::Mouse] = new Mouse(InputDeviceEnumerator::Mouse, oisInputManager_);
232            }
233            catch (const std::exception& ex)
234            {
235                CCOUT(2) << "Warning: Failed to create Mouse:" << ex.what() << std::endl
236                         << "Proceeding without mouse support." << std::endl;
237            }
238        }
239        else
240            CCOUT(ORX_WARNING) << "Warning: No mouse found! Proceeding without mouse support." << std::endl;
241    }
242
243    //! Creates as many joy sticks as are available.
244    void InputManager::loadJoySticks()
245    {
246        for (int i = 0; i < oisInputManager_->getNumberOfDevices(OIS::OISJoyStick); i++)
247        {
248            try
249            {
250                devices_.push_back(new JoyStick(InputDeviceEnumerator::FirstJoyStick + i, oisInputManager_));
251            }
252            catch (const std::exception& ex)
253            {
254                CCOUT(2) << "Warning: Failed to create joy stick: " << ex.what() << std::endl;
255            }
256        }
257
258        // inform all JoyStick Device Number Listeners
259        std::vector<JoyStick*> joyStickList;
260        for (unsigned int i = InputDeviceEnumerator::FirstJoyStick; i < devices_.size(); ++i)
261            joyStickList.push_back(static_cast<JoyStick*>(devices_[i]));
262        JoyStickQuantityListener::changeJoyStickQuantity(joyStickList);
263    }
264
265    void InputManager::setKeyDetectorCallback(const std::string& command)
266    {
267        this->keyDetector_->setCallbackCommand(command);
268    }
269
270    // ############################################################
271    // #####                    Destruction                   #####
272    // ##########                                        ##########
273    // ############################################################
274
275    InputManager::~InputManager()
276    {
277        CCOUT(4) << "Destroying..." << std::endl;
278
279        // Destroy calibrator helper handler and state
280        delete keyDetector_;
281        this->destroyState("calibrator");
282        // Destroy KeyDetector and state
283        delete calibratorCallbackHandler_;
284        this->destroyState("detector");
285        // destroy the empty InputState
286        this->destroyStateInternal(this->emptyState_);
287
288        // destroy all user InputStates
289        while (statesByName_.size() > 0)
290            this->destroyStateInternal((*statesByName_.rbegin()).second);
291
292        if (!(internalState_ & Bad))
293            this->destroyDevices();
294
295        CCOUT(4) << "Destruction complete." << std::endl;
296    }
297
298    /**
299    @brief
300        Destoys all input devices (joy sticks, mouse, keyboard and OIS::InputManager)
301    @throw
302        Method does not throw
303    */
304    void InputManager::destroyDevices()
305    {
306        CCOUT(3) << "Destroying devices..." << std::endl;
307
308        BOOST_FOREACH(InputDevice*& device, devices_)
309        {
310            if (device == NULL)
311                continue;
312            std::string className = device->getClassName();
313            try
314            {
315                delete device;
316                device = 0;
317                CCOUT(4) << className << " destroyed." << std::endl;
318            }
319            catch (...)
320            {
321                CCOUT(1) << className << " destruction failed! Potential resource leak!" << std::endl;
322            }
323        }
324        devices_.resize(InputDeviceEnumerator::FirstJoyStick);
325
326        assert(oisInputManager_ != NULL);
327        try
328        {
329            OIS::InputManager::destroyInputSystem(oisInputManager_);
330        }
331        catch (...)
332        {
333            CCOUT(1) << "OIS::InputManager destruction failed! Potential resource leak!" << std::endl;
334        }
335        oisInputManager_ = NULL;
336
337        internalState_ |= Bad;
338        CCOUT(3) << "Destroyed devices." << std::endl;
339    }
340
341    // ############################################################
342    // #####                     Reloading                    #####
343    // ##########                                        ##########
344    // ############################################################
345
346    void InputManager::reload()
347    {
348        if (internalState_ & Ticking)
349        {
350            // We cannot destroy OIS right now, because reload was probably
351            // caused by a user clicking on a GUI item. The stack trace would then
352            // include an OIS method. So it would be a very bad thing to destroy it..
353            internalState_ |= ReloadRequest;
354        }
355        else if (internalState_ & Calibrating)
356            CCOUT(2) << "Warning: Cannot reload input system. Joy sticks are currently being calibrated." << std::endl;
357        else
358            reloadInternal();
359    }
360
361    //! Internal reload method. Destroys the OIS devices and loads them again.
362    void InputManager::reloadInternal()
363    {
364        CCOUT(3) << "Reloading ..." << std::endl;
365
366        this->destroyDevices();
367        this->loadDevices(windowHnd_);
368
369        internalState_ &= ~Bad;
370        internalState_ &= ~ReloadRequest;
371        CCOUT(3) << "Reloading complete." << std::endl;
372    }
373
374    // ############################################################
375    // #####                  Runtime Methods                 #####
376    // ##########                                        ##########
377    // ############################################################
378
379    void InputManager::update(const Clock& time)
380    {
381        if (internalState_ & Bad)
382            ThrowException(General, "InputManager was not correctly reloaded.");
383
384        else if (internalState_ & ReloadRequest)
385            reloadInternal();
386
387        // check for states to leave
388        if (!stateLeaveRequests_.empty())
389        {
390            for (std::set<InputState*>::iterator it = stateLeaveRequests_.begin();
391                it != stateLeaveRequests_.end(); ++it)
392            {
393                (*it)->left();
394                // just to be sure that the state actually is registered
395                assert(statesByName_.find((*it)->getName()) != statesByName_.end());
396
397                activeStates_.erase((*it)->getPriority());
398                if ((*it)->getPriority() < InputStatePriority::HighPriority)
399                    (*it)->setPriority(0);
400                updateActiveStates();
401            }
402            stateLeaveRequests_.clear();
403        }
404
405        // check for states to enter
406        if (!stateEnterRequests_.empty())
407        {
408            for (std::set<InputState*>::const_iterator it = stateEnterRequests_.begin();
409                it != stateEnterRequests_.end(); ++it)
410            {
411                // just to be sure that the state actually is registered
412                assert(statesByName_.find((*it)->getName()) != statesByName_.end());
413
414                if ((*it)->getPriority() == 0)
415                {
416                    // Get smallest possible priority between 1 and maxStateStackSize_s
417                    for(std::map<int, InputState*>::reverse_iterator rit = activeStates_.rbegin();
418                        rit != activeStates_.rend(); ++rit)
419                    {
420                        if (rit->first < InputStatePriority::HighPriority)
421                        {
422                            (*it)->setPriority(rit->first + 1);
423                            break;
424                        }
425                    }
426                    // In case no normal handler was on the stack
427                    if ((*it)->getPriority() == 0)
428                        (*it)->setPriority(1);
429                }
430                activeStates_[(*it)->getPriority()] = (*it);
431                updateActiveStates();
432                (*it)->entered();
433            }
434            stateEnterRequests_.clear();
435        }
436
437        // check for states to destroy
438        if (!stateDestroyRequests_.empty())
439        {
440            for (std::set<InputState*>::iterator it = stateDestroyRequests_.begin();
441                it != stateDestroyRequests_.end(); ++it)
442            {
443                destroyStateInternal((*it));
444            }
445            stateDestroyRequests_.clear();
446        }
447
448        // check whether a state has changed its EMPTY situation
449        bool bUpdateRequired = false;
450        for (std::map<int, InputState*>::iterator it = activeStates_.begin(); it != activeStates_.end(); ++it)
451        {
452            if (it->second->hasExpired())
453            {
454                it->second->resetExpiration();
455                bUpdateRequired = true;
456            }
457        }
458        if (bUpdateRequired)
459            updateActiveStates();
460
461        // mark that we now start capturing and distributing input
462        internalState_ |= Ticking;
463
464        // Capture all the input and handle it
465        BOOST_FOREACH(InputDevice* device, devices_)
466            if (device != NULL)
467                device->update(time);
468
469        // Update the states
470        for (unsigned int i = 0; i < activeStatesTicked_.size(); ++i)
471            activeStatesTicked_[i]->update(time.getDeltaTime());
472
473        internalState_ &= ~Ticking;
474    }
475
476    /**
477    @brief
478        Updates the currently active states (according to activeStates_) for each device.
479        Also, a list of all active states (no duplicates!) is compiled for the general update().
480    */
481    void InputManager::updateActiveStates()
482    {
483        // temporary resize
484        for (unsigned int i = 0; i < devices_.size(); ++i)
485        {
486            if (devices_[i] == NULL)
487                continue;
488            std::vector<InputState*>& states = devices_[i]->getStateListRef();
489            bool occupied = false;
490            states.clear();
491            for (std::map<int, InputState*>::reverse_iterator rit = activeStates_.rbegin(); rit != activeStates_.rend(); ++rit)
492            {
493                if (rit->second->isInputDeviceEnabled(i) && (!occupied || rit->second->bAlwaysGetsInput_))
494                {
495                    states.push_back(rit->second);
496                    if (!rit->second->bTransparent_)
497                        occupied = true;
498                }
499            }
500        }
501
502        // update tickables (every state will only appear once)
503        // Using a std::set to avoid duplicates
504        std::set<InputState*> tempSet;
505        for (unsigned int i = 0; i < devices_.size(); ++i)
506            if (devices_[i] != NULL)
507                for (unsigned int iState = 0; iState < devices_[i]->getStateListRef().size(); ++iState)
508                    tempSet.insert(devices_[i]->getStateListRef()[iState]);
509
510        // copy the content of the std::set back to the actual vector
511        activeStatesTicked_.clear();
512        for (std::set<InputState*>::const_iterator it = tempSet.begin();it != tempSet.end(); ++it)
513            activeStatesTicked_.push_back(*it);
514    }
515
516    void InputManager::clearBuffers()
517    {
518        BOOST_FOREACH(InputDevice* device, devices_)
519            if (device != NULL)
520                device->clearBuffers();
521    }
522
523    void InputManager::calibrate()
524    {
525        COUT(0) << "Move all joy stick axes fully in all directions." << std::endl
526                << "When done, put the axex in the middle position and press enter." << std::endl;
527
528        BOOST_FOREACH(InputDevice* device, devices_)
529            if (device != NULL)
530                device->startCalibration();
531
532        internalState_ |= Calibrating;
533        enterState("calibrator");
534    }
535
536    //! Tells all devices to stop the calibration and evaluate it. Buffers are being cleared as well!
537    void InputManager::stopCalibration()
538    {
539        BOOST_FOREACH(InputDevice* device, devices_)
540            if (device != NULL)
541                device->stopCalibration();
542
543        // restore old input state
544        leaveState("calibrator");
545        internalState_ &= ~Calibrating;
546        // Clear buffers to prevent button hold events
547        this->clearBuffers();
548
549        COUT(0) << "Calibration has been stored." << std::endl;
550    }
551
552    //! Gets called by WindowEventListener upon focus change --> clear buffers
553    void InputManager::windowFocusChanged()
554    {
555        this->clearBuffers();
556    }
557
558    // ############################################################
559    // #####                    Iput States                   #####
560    // ##########                                        ##########
561    // ############################################################
562
563    InputState* InputManager::createInputState(const std::string& name, bool bAlwaysGetsInput, bool bTransparent, InputStatePriority priority)
564    {
565        if (name == "")
566            return 0;
567        if (statesByName_.find(name) == statesByName_.end())
568        {
569            if (priority >= InputStatePriority::HighPriority || priority == InputStatePriority::Empty)
570            {
571                // Make sure we don't add two high priority states with the same priority
572                for (std::map<std::string, InputState*>::const_iterator it = this->statesByName_.begin();
573                    it != this->statesByName_.end(); ++it)
574                {
575                    if (it->second->getPriority() == priority)
576                    {
577                        COUT(2) << "Warning: Could not add an InputState with the same priority '"
578                            << static_cast<int>(priority) << "' != 0." << std::endl;
579                        return 0;
580                    }
581                }
582            }
583            InputState* state = new InputState(name, bAlwaysGetsInput, bTransparent, priority);
584            statesByName_[name] = state;
585
586            return state;
587        }
588        else
589        {
590            COUT(2) << "Warning: Could not add an InputState with the same name '" << name << "'." << std::endl;
591            return 0;
592        }
593    }
594
595    InputState* InputManager::getState(const std::string& name)
596    {
597        std::map<std::string, InputState*>::iterator it = statesByName_.find(name);
598        if (it != statesByName_.end())
599            return it->second;
600        else
601            return 0;
602    }
603
604    bool InputManager::enterState(const std::string& name)
605    {
606        // get pointer from the map with all stored handlers
607        std::map<std::string, InputState*>::const_iterator it = statesByName_.find(name);
608        if (it != statesByName_.end())
609        {
610            // exists
611            if (activeStates_.find(it->second->getPriority()) == activeStates_.end())
612            {
613                // not active
614                if (stateDestroyRequests_.find(it->second) == stateDestroyRequests_.end())
615                {
616                    // not scheduled for destruction
617                    // prevents a state being added multiple times
618                    stateEnterRequests_.insert(it->second);
619                    return true;
620                }
621            }
622        }
623        return false;
624    }
625
626    bool InputManager::leaveState(const std::string& name)
627    {
628        if (name == "empty")
629        {
630            COUT(2) << "InputManager: Leaving the empty state is not allowed!" << std::endl;
631            return false;
632        }
633        // get pointer from the map with all stored handlers
634        std::map<std::string, InputState*>::const_iterator it = statesByName_.find(name);
635        if (it != statesByName_.end())
636        {
637            // exists
638            if (activeStates_.find(it->second->getPriority()) != activeStates_.end())
639            {
640                // active
641                stateLeaveRequests_.insert(it->second);
642                return true;
643            }
644        }
645        return false;
646    }
647
648    bool InputManager::destroyState(const std::string& name)
649    {
650        if (name == "empty")
651        {
652            COUT(2) << "InputManager: Removing the empty state is not allowed!" << std::endl;
653            return false;
654        }
655        std::map<std::string, InputState*>::iterator it = statesByName_.find(name);
656        if (it != statesByName_.end())
657        {
658            if (activeStates_.find(it->second->getPriority()) != activeStates_.end())
659            {
660                // The state is still active. We have to postpone
661                stateLeaveRequests_.insert(it->second);
662                stateDestroyRequests_.insert(it->second);
663            }
664            else if (this->internalState_ & Ticking)
665            {
666                // cannot remove state while ticking
667                stateDestroyRequests_.insert(it->second);
668            }
669            else
670                destroyStateInternal(it->second);
671
672            return true;
673        }
674        return false;
675    }
676
677    //! Destroys an InputState internally.
678    void InputManager::destroyStateInternal(InputState* state)
679    {
680        assert(state && !(this->internalState_ & Ticking));
681        std::map<int, InputState*>::iterator it = this->activeStates_.find(state->getPriority());
682        if (it != this->activeStates_.end())
683        {
684            this->activeStates_.erase(it);
685            updateActiveStates();
686        }
687        statesByName_.erase(state->getName());
688        delete state;
689    }
690}
Note: See TracBrowser for help on using the repository browser.