Changeset 1878 for code/trunk/src/core/input

Timestamp:

Oct 3, 2008, 1:26:48 PM (16 years ago)

Author:

rgrieder

Message:

Fixed two issues with input:

• Buffer gets cleared now when the window focus changes
• Added a configValue in the InGameConsole:

Until now the input was always transparent to the level when activating the console (exception keyboard input of course)
bHidesAllInput_ can change that setting (configured in orxonox.ini)

@Oli: Sorry, couldn't apply the patch in the network branch because of conflicts (I have already made some changes to the InputManager in the trunk)

Location:

code/trunk/src/core/input

Files:

• ExtendedInputState.cc (modified) (6 diffs)
• ExtendedInputState.h (modified) (2 diffs)
• InputInterfaces.h (modified) (5 diffs)
• InputManager.cc (modified) (6 diffs)
• InputManager.h (modified) (5 diffs)
• InputState.h (modified) (3 diffs)
• SimpleInputState.cc (modified) (5 diffs)
• SimpleInputState.h (modified) (2 diffs)

code/trunk/src/core/input/ExtendedInputState.cc

@@ -366 +366 @@
     void ExtendedInputState::removeAndDestroyAllHandlers()
     {
-        for (std::vector<InputTickable*>::iterator it = allHandlers_.begin();
+        for (std::vector<InputHandler*>::iterator it = allHandlers_.begin();
             it != allHandlers_.end(); ++it)
             delete *it;
@@ -387 +387 @@
         True if added, false if handler already existed.
     */
-    bool ExtendedInputState::addHandler(InputTickable* handler)
+    bool ExtendedInputState::addHandler(InputHandler* handler)
     {
         bool success = false;
@@ -406 +406 @@
         True if removal was successful, false if handler was not found.
     */
-    bool ExtendedInputState::removeHandler(InputTickable* handler)
+    bool ExtendedInputState::removeHandler(InputHandler* handler)
     {
         bool success = false;
@@ -449 +449 @@
     {
         // we can use a set to have a list of unique pointers (an object can implement all 3 handlers)
-        std::set<InputTickable*> tempSet;
+        std::set<InputHandler*> tempSet;
         for (unsigned int iHandler = 0; iHandler < keyHandlers_.size(); iHandler++)
             tempSet.insert(keyHandlers_[iHandler]);
@@ -460 +460 @@
         // copy the content of the map back to the actual vector
         allHandlers_.clear();
-        for (std::set<InputTickable*>::const_iterator itHandler = tempSet.begin();
+        for (std::set<InputHandler*>::const_iterator itHandler = tempSet.begin();
             itHandler != tempSet.end(); itHandler++)
             allHandlers_.push_back(*itHandler);
@@ -469 +469 @@
         for (unsigned int i = 0; i < joyStickHandlers_.size(); ++i)
             setInputDeviceEnabled(2 + i, (joyStickHandlers_[i].size() != 0));
+
+        this->bHandlersChanged_ = true;
     }
 }

code/trunk/src/core/input/ExtendedInputState.h

@@ -61 +61 @@
         bool removeJoyStickHandler(JoyStickHandler* handler);
 
-        bool addHandler(InputTickable* handler);
-        bool removeHandler(InputTickable* handler);
+        bool addHandler(InputHandler* handler);
+        bool removeHandler(InputHandler* handler);
 
         void removeAndDestroyAllHandlers();
@@ -96 +96 @@
         std::vector<JoyStickHandler*>               joyStickHandlersAll_;
 
-        std::vector<InputTickable*> allHandlers_;
+        std::vector<InputHandler*> allHandlers_;
     };
 }

code/trunk/src/core/input/InputInterfaces.h

@@ -287 +287 @@
 
 
-    class _CoreExport InputTickable
-    {
-    public:
-        virtual ~InputTickable() { }
+    class _CoreExport InputHandler
+    {
+    public:
+        virtual ~InputHandler() { }
         virtual void tickInput(float dt) = 0;
     };
@@ -298 +298 @@
         Interface class used for key input listeners.
     */
-    class _CoreExport KeyHandler : virtual public InputTickable
+    class _CoreExport KeyHandler : virtual public InputHandler
     {
     public:
@@ -312 +312 @@
         Interface class used for mouse input listeners.
     */
-    class _CoreExport MouseHandler : virtual public InputTickable
+    class _CoreExport MouseHandler : virtual public InputHandler
     {
     public:
@@ -329 +329 @@
         Interface class used for joy stick input listeners.
     */
-    class _CoreExport JoyStickHandler : virtual public InputTickable
+    class _CoreExport JoyStickHandler : virtual public InputHandler
     {
     public:
@@ -342 +342 @@
     class _CoreExport EmptyHandler : public KeyHandler, public MouseHandler, public JoyStickHandler
     {
+        friend class InputManager;
     private:
+        EmptyHandler() { }
+        EmptyHandler(EmptyHandler&);
+        virtual ~EmptyHandler() { }
+
         void tickInput(float dt) { }
         void tickJoyStick(float dt, unsigned int joyStick) { }

code/trunk/src/core/input/InputManager.cc

@@ -65 +65 @@
 
     std::string InputManager::bindingCommmandString_s = "";
+    EmptyHandler InputManager::EMPTY_HANDLER;
     InputManager* InputManager::singletonRef_s = 0;
 
@@ -189 +190 @@
 
             stateEmpty_ = createInputState<SimpleInputState>("empty", -1);
-            stateEmpty_->setHandler(new EmptyHandler());
+            stateEmpty_->setHandler(&EMPTY_HANDLER);
             activeStates_[stateEmpty_->getPriority()] = stateEmpty_;
 
@@ -198 +199 @@
 
             stateCalibrator_ = createInputState<SimpleInputState>("calibrator", 100);
-            stateCalibrator_->setHandler(new EmptyHandler());
+            stateCalibrator_->setHandler(&EMPTY_HANDLER);
             InputBuffer* buffer = new InputBuffer();
             buffer->registerListener(this, &InputManager::_completeCalibration, '\r', true);
@@ -430 +431 @@
 
                 // clear our own states
-                stateEmpty_->removeAndDestroyAllHandlers();
-                stateCalibrator_->removeAndDestroyAllHandlers();
-                stateDetector_->removeAndDestroyAllHandlers();
+                //stateEmpty_->removeAndDestroyAllHandlers();
+                //stateCalibrator_->removeAndDestroyAllHandlers();
+                //stateDetector_->removeAndDestroyAllHandlers();
+                // TODO: Memory Leak when not deleting the handlers!!!
 
                 // kick all active states 'nicely'
@@ -680 +682 @@
         }
         stateDestroyRequests_.clear();
+
+        // check whether a state has changed its EMPTY_HANDLER situation
+        bool bUpdateRequired = false;
+        for (std::map<int, InputState*>::iterator it = activeStates_.begin(); it != activeStates_.end(); ++it)
+        {
+            if (it->second->handlersChanged())
+            {
+                it->second->resetHandlersChanged();
+                bUpdateRequired = true;
+            }
+        }
+        if (bUpdateRequired)
+            _updateActiveStates();
 
         // mark that we capture and distribute input
@@ -826 +841 @@
         requestLeaveState("calibrator");
         bCalibrating_ = false;
+    }
+
+    void InputManager::clearBuffers()
+    {
+        this->keysDown_.clear();
+        this->mouseButtonsDown_.clear();
+        for (unsigned int i = 0; i < this->joySticksSize_; ++i)
+            this->joyStickButtonsDown_[i].clear();
     }
 

code/trunk/src/core/input/InputManager.h

@@ -108 +108 @@
         void reloadInputSystem(bool joyStickSupport = true);
 
+        void clearBuffers();
+
         int  numberOfKeyboards() { return keyboard_ ? 1 : 0; }
         int  numberOfMice()      { return mouse_    ? 1 : 0; }
@@ -115 +117 @@
 
         template <class T>
-        T* createInputState(const std::string& name, int priority)
-        {
-            T* state = new T;
-            if (_configureInputState(state, name, priority))
-                return state;
-            else
-            {
-                delete state;
-                return 0;
-            }
-        }
+        T* createInputState(const std::string& name, int priority);
 
         InputState* getState       (const std::string& name);
@@ -139 +131 @@
         static InputManager* getInstancePtr() { return singletonRef_s; }
 
-    public: // console commands
+        // console commands
         static void storeKeyStroke(const std::string& name);
         static void keyBind(const std::string& command);
         static void calibrate();
         static void reload(bool joyStickSupport = true);
+
+    public: // variables
+        static EmptyHandler                 EMPTY_HANDLER;
 
     private: // functions
@@ -197 +192 @@
         InputManagerState                   internalState_;        //!< Current internal state
 
-        // some internally handled states
+        // some internally handled states and handlers
         SimpleInputState*                   stateDetector_;        //!< KeyDetector instance
         SimpleInputState*                   stateCalibrator_;
@@ -234 +229 @@
         static InputManager*                singletonRef_s;
     };
+
+    /**
+    @brief
+        Creates a new InputState by type, name and priority.
+        
+        You will have to use this method because the
+        c'tors and d'tors are private.
+    @remarks
+        The InputManager will take care of the state completely. That also
+        means it gets deleted when the InputManager is destroyed!
+    @param name
+        Name of the InputState when referenced as string
+    @param priority
+        Priority matters when multiple states are active. You can specify any
+        number, but 1 - 99 is preferred (99 means high).
+    */
+    template <class T>
+    T* InputManager::createInputState(const std::string& name, int priority)
+    {
+        T* state = new T;
+        if (_configureInputState(state, name, priority))
+            return state;
+        else
+        {
+            delete state;
+            return 0;
+        }
+    }
 }
 

code/trunk/src/core/input/InputState.h

@@ -60 +60 @@
         }
 
+        bool handlersChanged() { return this->bHandlersChanged_; }
+        void resetHandlersChanged() { bHandlersChanged_ = false; }
+
         virtual void onEnter() { if (executorOnEnter_) (*executorOnEnter_)(); }
         virtual void onLeave() { if (executorOnLeave_) (*executorOnLeave_)(); }
@@ -87 +90 @@
 
     protected:
-        InputState() : priority_(0), executorOnEnter_(0), executorOnLeave_(0) { }
+        InputState() : priority_(0), bHandlersChanged_(false), executorOnEnter_(0), executorOnLeave_(0) { }
         virtual ~InputState() { }
 
@@ -96 +99 @@
                 bInputDeviceEnabled_[device] = bEnabled;
         }
+
+        bool bHandlersChanged_;
 
     private:

code/trunk/src/core/input/SimpleInputState.cc

@@ -184 +184 @@
     }
 
-    void SimpleInputState::removeAndDestroyAllHandlers()
-    {
-        for (std::vector<InputTickable*>::iterator it = allHandlers_.begin();
-            it != allHandlers_.end(); ++it)
-            delete *it;
-
-        allHandlers_.clear();
-        keyHandler_ = 0;
-        mouseHandler_ = 0;
-        joyStickHandlerAll_ = 0;
-        for (unsigned int iJoyStick = 0; iJoyStick < joyStickHandler_.size(); ++iJoyStick)
-            joyStickHandler_[iJoyStick] = 0;
-
-        update();
-    }
+    //void SimpleInputState::removeAndDestroyAllHandlers()
+    //{
+    //    for (std::vector<InputHandler*>::iterator it = allHandlers_.begin();
+    //        it != allHandlers_.end(); ++it)
+    //        delete *it;
+
+    //    allHandlers_.clear();
+    //    keyHandler_ = 0;
+    //    mouseHandler_ = 0;
+    //    joyStickHandlerAll_ = 0;
+    //    for (unsigned int iJoyStick = 0; iJoyStick < joyStickHandler_.size(); ++iJoyStick)
+    //        joyStickHandler_[iJoyStick] = 0;
+
+    //    update();
+    //}
 
     /**
@@ -208 +208 @@
         True if added, false if handler already existed.
     */
-    bool SimpleInputState::setHandler(InputTickable* handler)
+    bool SimpleInputState::setHandler(InputHandler* handler)
     {
         setKeyHandler(dynamic_cast<KeyHandler*>(handler));
@@ -247 +247 @@
     {
         // we can use a set to have a list of unique pointers (an object can implement all 3 handlers)
-        std::set<InputTickable*> tempSet;
+        std::set<InputHandler*> tempSet;
         if (keyHandler_)
             tempSet.insert(keyHandler_);
@@ -258 +258 @@
         // copy the content of the map back to the actual vector
         allHandlers_.clear();
-        for (std::set<InputTickable*>::const_iterator itHandler = tempSet.begin();
+        for (std::set<InputHandler*>::const_iterator itHandler = tempSet.begin();
             itHandler != tempSet.end(); itHandler++)
             allHandlers_.push_back(*itHandler);
@@ -267 +267 @@
         for (unsigned int i = 0; i < joyStickHandler_.size(); ++i)
             setInputDeviceEnabled(2 + i, (joyStickHandler_[i] != 0));
+
+        // inform InputManager that there might be changes in EMPTY_HANDLER situation
+        bHandlersChanged_ = true;
     }
 }

code/trunk/src/core/input/SimpleInputState.h

@@ -52 +52 @@
         bool setJoyStickHandler   (JoyStickHandler* handler, unsigned int joyStickID);
         bool setJoyStickHandler   (JoyStickHandler* handler);
-        bool setHandler(InputTickable* handler);
-        void removeAndDestroyAllHandlers();
+        bool setHandler(InputHandler* handler);
+        //void removeAndDestroyAllHandlers();
 
     private:
@@ -84 +84 @@
         std::vector<JoyStickHandler*> joyStickHandler_;
         JoyStickHandler*              joyStickHandlerAll_;
-        std::vector<InputTickable*>   allHandlers_;
+        std::vector<InputHandler*>   allHandlers_;
     };
 }