Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: code/branches/core5/src/libraries/core/input/InputManager.cc @ 5855

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

Note: See TracBrowser for help on using the repository browser.

Download in other formats: