Changeset 1670 for code/branches/gui/src/core/input

Timestamp:

Aug 26, 2008, 4:26:04 PM (16 years ago)

Author:

rgrieder

Message:

Still working on the GameStates, but I have to save the work because of some major changes.

• Exported InputManager- and TclThreadManager-tick to GSGraphics instead of Core
• Fixed a few bugs in GameState by adding an internal state variable as bitfield (quite practical)
• Fixed a bug in InputManager that occurred when destroying an active InputState
• Added GSIO and GSIOConsole (3 lines of loop code with std::cin, but works )
• Added more boost thread includes to OrxonoxStableHeaders.h
• Many changes in all GameState derived classes

Location:

code/branches/gui/src/core/input

Files:

• InputManager.cc (modified) (10 diffs)
• InputManager.h (modified) (3 diffs)

code/branches/gui/src/core/input/InputManager.cc

@@ -348 +348 @@
         for (std::map<int, InputState*>::const_iterator it = inputStatesByPriority_.begin();
             it != inputStatesByPriority_.end(); ++it)
-            (*it).second->setNumOfJoySticks(joySticksSize_);
+            it->second->setNumOfJoySticks(joySticksSize_);
     }
 
@@ -506 +506 @@
     }
 
+    /**
+    @brief
+        Removes and destroys an InputState.
+    @return
+        True if state was removed immediately, false if postponed.
+    */
     void InputManager::_destroyState(InputState* state)
     {
-        assert(state);
+        assert(state && !(this->internalState_ & Ticking));
         std::map<int, InputState*>::iterator it = this->activeStates_.find(state->getPriority());
         if (it != this->activeStates_.end())
@@ -633 +639 @@
         internalState_ |= Ticking;
 
-        // check for states to leave (don't use unsigned int!)
-        for (int i = stateLeaveRequests_.size() - 1; i >= 0; --i)
-        {
-            stateLeaveRequests_[i]->onLeave();
+        // check for states to leave
+        for (std::set<InputState*>::reverse_iterator it = stateLeaveRequests_.rbegin();
+            it != stateLeaveRequests_.rend(); ++it)
+        {
+            (*it)->onLeave();
             // just to be sure that the state actually is registered
-            assert(inputStatesByName_.find(stateLeaveRequests_[i]->getName()) != inputStatesByName_.end());
-            
-            activeStates_.erase(stateLeaveRequests_[i]->getPriority());
+            assert(inputStatesByName_.find((*it)->getName()) != inputStatesByName_.end());
+
+            activeStates_.erase((*it)->getPriority());
             _updateActiveStates();
-            stateLeaveRequests_.pop_back();
-        }
-
-
-        // check for states to enter (don't use unsigned int!)
-        for (int i = stateEnterRequests_.size() - 1; i >= 0; --i)
+        }
+        stateLeaveRequests_.clear();
+
+        // check for states to enter
+        for (std::set<InputState*>::reverse_iterator it = stateEnterRequests_.rbegin();
+            it != stateEnterRequests_.rend(); ++it)
         {
             // just to be sure that the state actually is registered
-            assert(inputStatesByName_.find(stateEnterRequests_[i]->getName()) != inputStatesByName_.end());
-            
-            activeStates_[stateEnterRequests_[i]->getPriority()] = stateEnterRequests_[i];
+            assert(inputStatesByName_.find((*it)->getName()) != inputStatesByName_.end());
+
+            activeStates_[(*it)->getPriority()] = (*it);
             _updateActiveStates();
-            stateEnterRequests_[i]->onEnter();
-            stateEnterRequests_.pop_back();
+            (*it)->onEnter();
+        }
+        stateEnterRequests_.clear();
+
+        // check for states to destroy
+        for (std::set<InputState*>::reverse_iterator it = stateDestroyRequests_.rbegin();
+            it != stateDestroyRequests_.rend(); ++it)
+        {
+            _destroyState((*it));
         }
 
@@ -703 +717 @@
         for (std::map<int, InputState*>::const_iterator it = activeStates_.begin(); it != activeStates_.end(); ++it)
             for (unsigned int i = 0; i < devicesNum_; ++i)
-                if ((*it).second->isInputDeviceEnabled(i))
-                    activeStatesTop_[i] = (*it).second;
+                if (it->second->isInputDeviceEnabled(i))
+                    activeStatesTop_[i] = it->second;
 
         // update tickables (every state will only appear once)
@@ -1135 +1149 @@
     /**
     @brief
-        Removes an input state internally.
+        Removes and destroys an input state internally.
     @param name
         Name of the handler.
@@ -1142 +1156 @@
     @remarks
         You can't remove the internal states "empty", "calibrator" and "detector".
-    */
-    bool InputManager::destroyState(const std::string& name)
+        The removal process is being postponed if InputManager::tick() is currently running.
+    */
+    bool InputManager::requestDestroyState(const std::string& name)
     {
         if (name == "empty" || name == "calibrator" || name == "detector")
@@ -1153 +1168 @@
         if (it != inputStatesByName_.end())
         {
-            _destroyState((*it).second);
+            if (activeStates_.find(it->second->getPriority()) != activeStates_.end())
+            {
+                // The state is still active. We have to postpone
+                stateLeaveRequests_.insert(it->second);
+                stateDestroyRequests_.insert(it->second);
+            }
+            else if (this->internalState_ & Ticking)
+            {
+                // cannot remove state while ticking
+                stateDestroyRequests_.insert(it->second);
+            }
+            else
+                _destroyState(it->second);
+
             return true;
         }
@@ -1171 +1199 @@
         std::map<std::string, InputState*>::iterator it = inputStatesByName_.find(name);
         if (it != inputStatesByName_.end())
-            return (*it).second;
+            return it->second;
         else
             return 0;
@@ -1202 +1230 @@
         if (it != inputStatesByName_.end())
         {
-            stateEnterRequests_.push_back((*it).second);
-            return true;
+            // exists
+            if (activeStates_.find(it->second->getPriority()) == activeStates_.end())
+            {
+                // not active
+                if (stateDestroyRequests_.find(it->second) == stateDestroyRequests_.end())
+                {
+                    // not scheduled for destruction
+                    // set prevents a state being added multiple times
+                    stateEnterRequests_.insert(it->second);
+                    return true;
+                }
+            }
         }
         return false;
@@ -1222 +1260 @@
         if (it != inputStatesByName_.end())
         {
-            stateLeaveRequests_.push_back((*it).second);
-            return true;
+            // exists
+            if (activeStates_.find(it->second->getPriority()) != activeStates_.end())
+            {
+                // active
+                stateLeaveRequests_.insert(it->second);
+                return true;
+            }
         }
         return false;

code/branches/gui/src/core/input/InputManager.h

@@ -127 +127 @@
         }
 
-        bool destroyState          (const std::string& name);
         InputState* getState       (const std::string& name);
         InputState* getCurrentState();
+        bool requestDestroyState   (const std::string& name);
         bool requestEnterState     (const std::string& name);
         bool requestLeaveState     (const std::string& name);
+
+        void tick(float dt);
 
         static InputManager& getInstance()    { assert(singletonRef_s); return *singletonRef_s; }
@@ -167 +169 @@
         void _updateActiveStates();
         bool _configureInputState(InputState* state, const std::string& name, int priority);
-
-        void tick(float dt);
 
         // input events
@@ -204 +204 @@
         std::map<int, InputState*>          inputStatesByPriority_;
 
-        std::vector<InputState*>            stateEnterRequests_;   //!< Request to enter a new state
-        std::vector<InputState*>            stateLeaveRequests_;   //!< Request to leave the current state
+        std::set<InputState*>               stateEnterRequests_;   //!< Request to enter a new state
+        std::set<InputState*>               stateLeaveRequests_;   //!< Request to leave a running state
+        std::set<InputState*>               stateDestroyRequests_; //!< Request to destroy a state
 
         std::map<int, InputState*>          activeStates_;