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

Timestamp:

Feb 14, 2009, 10:17:35 PM (16 years ago)

Author:

rgrieder

Message:

Merged presentation branch back to trunk.

Location:

code/trunk

Files:

• . (modified) (1 prop)
• src/core/input/Button.cc (modified) (1 diff)
• src/core/input/Button.h (modified) (1 diff)
• src/core/input/InputBuffer.cc (modified) (1 diff)
• src/core/input/InputBuffer.h (modified) (1 diff)
• src/core/input/InputInterfaces.h (modified) (2 diffs)
• src/core/input/InputManager.cc (modified) (15 diffs)
• src/core/input/InputManager.h (modified) (9 diffs)
• src/core/input/KeyBinder.cc (modified) (13 diffs)
• src/core/input/KeyBinder.h (modified) (3 diffs)

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

@@ -59 +59 @@
         nCommands_[1]=0;
         nCommands_[2]=0;
+        this->configContainer_ = 0;
         clear();
+    }
+
+    Button::~Button()
+    {
+        this->clear();
+
+        if (this->configContainer_)
+            delete this->configContainer_;
     }
 

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

@@ -49 +49 @@
     public:
         Button();
-        virtual ~Button() { clear(); }
+        virtual ~Button();
         virtual void clear();
         virtual bool addParamCommand(ParamCommand* command) { return false; }

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

@@ -73 +73 @@
     }
 
+    InputBuffer::~InputBuffer()
+    {
+        for (std::list<BaseInputBufferListenerTuple*>::const_iterator it = this->listeners_.begin();
+            it != this->listeners_.end(); ++it)
+            delete *it;
+    }
+
     void InputBuffer::setConfigValues()
     {

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

@@ -79 +79 @@
         public:
             InputBuffer();
+            ~InputBuffer();
             InputBuffer(const std::string allowedChars);
 

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

@@ -378 +378 @@
         const char* const ByString[] =
         {
-            "Button0",       "Button1",       "Button2",       "Button3",
-            "Button4",       "Button5",       "Button6",       "Button7",
-            "Button8",       "Button9",       "Button10",      "Button11",
+            "Button00",      "Button01",      "Button02",      "Button03",
+            "Button04",      "Button05",      "Button06",      "Button07",
+            "Button08",      "Button09",      "Button10",      "Button11",
             "Button12",      "Button13",      "Button14",      "Button15",
             "Button16",      "Button17",      "Button18",      "Button19",
@@ -416 +416 @@
             "Slider0", "Slider1", "Slider2", "Slider3",
             "Slider4", "Slider5", "Slider6", "Slider7",
-            "Axis0",   "Axis1",   "Axis2",   "Axis3",
-            "Axis4",   "Axis5",   "Axis6",   "Axis7",
-            "Axis8",   "Axis9",   "Axis10",  "Axis11",
+            "Axis00",  "Axis01",  "Axis02",  "Axis03",
+            "Axis04",  "Axis05",  "Axis06",  "Axis07",
+            "Axis08",  "Axis09",  "Axis10",  "Axis11",
             "Axis12",  "Axis13",  "Axis14",  "Axis15"
         };

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

@@ -65 +65 @@
     SetCommandLineSwitch(keyboard_no_grab);
 
-    std::string InputManager::bindingCommmandString_s = "";
     EmptyHandler InputManager::EMPTY_HANDLER;
     InputManager* InputManager::singletonRef_s = 0;
@@ -112 +111 @@
         , keyDetector_(0)
         , calibratorCallbackBuffer_(0)
-        , bCalibrating_(false)
         , keyboardModifiers_(0)
     {
@@ -119 +117 @@
         assert(singletonRef_s == 0);
         singletonRef_s = this;
+
+        setConfigValues();
+    }
+
+    /**
+    @brief
+        Sets the configurable values.
+    */
+    void InputManager::setConfigValues()
+    {
+        SetConfigValue(calibrationFilename_, "joystick_calibration.ini")
+            .description("Ini filename for the the joy stick calibration data.")
+            .callback(this, &InputManager::_calibrationFileCallback);
+    }
+
+    /**
+    @brief
+        Callback for the joy stick calibration config file. @see setConfigValues.
+    */
+    void InputManager::_calibrationFileCallback()
+    {
+        ConfigFileManager::getInstance().setFilename(ConfigFileType::JoyStickCalibration, calibrationFilename_);
     }
 
@@ -174 +194 @@
             if (joyStickSupport)
                 _initialiseJoySticks();
-            // Do this anyway to also inform everyone if a joystick was detached.
-            _configureNumberOfJoySticks();
+            // Do this anyway to also inform everything when a joystick was detached.
+            _configureJoySticks();
 
             // Set mouse/joystick region
@@ -183 +203 @@
             // clear all buffers
             _clearBuffers();
-
-            // load joy stick calibration
-            setConfigValues();
 
             internalState_ |= OISReady;
@@ -335 +352 @@
     /**
     @brief
+        Helper function that loads the config value vector of one coefficient
+    */
+    void loadCalibration(std::vector<int>& list, const std::string& sectionName, const std::string& valueName, size_t size, int defaultValue)
+    {
+        list.resize(size);
+        unsigned int configValueVectorSize = ConfigFileManager::getInstance().getVectorSize(ConfigFileType::JoyStickCalibration, sectionName, valueName);
+        if (configValueVectorSize > size)
+            configValueVectorSize = size;
+
+        for (unsigned int i = 0; i < configValueVectorSize; ++i)
+        {
+            list[i] = omni_cast<int>(ConfigFileManager::getInstance().getValue(
+                ConfigFileType::JoyStickCalibration, sectionName, valueName, i, omni_cast<std::string>(defaultValue), false));
+        }
+
+        // fill the rest with default values
+        for (unsigned int i = configValueVectorSize; i < size; ++i)
+        {
+            list[i] = defaultValue;
+        }
+    }
+
+    /**
+    @brief
         Sets the size of all the different lists that are dependent on the number
-        of joy stick devices created.
+        of joy stick devices created and loads the joy stick calibration.
     @remarks
         No matter whether there are a mouse and/or keyboard, they will always
         occupy 2 places in the device number dependent lists.
     */
-    void InputManager::_configureNumberOfJoySticks()
+    void InputManager::_configureJoySticks()
     {
         joySticksSize_ = joySticks_.size();
-        devicesNum_ = 2 + joySticksSize_;
+        devicesNum_    = 2 + joySticksSize_;
+        joyStickIDs_         .resize(joySticksSize_);
         joyStickButtonsDown_ .resize(joySticksSize_);
         povStates_           .resize(joySticksSize_);
         sliderStates_        .resize(joySticksSize_);
-        joySticksCalibration_.resize(joySticksSize_);
+        joyStickMinValues_   .resize(joySticksSize_);
+        joyStickMaxValues_   .resize(joySticksSize_);
+        joyStickMiddleValues_.resize(joySticksSize_);
+        joyStickCalibrations_.resize(joySticksSize_);
 
         for (unsigned int iJoyStick = 0; iJoyStick < joySticksSize_; iJoyStick++)
         {
-            // reset the calibration with default values
-            for (unsigned int i = 0; i < 24; i++)
-            {
-                joySticksCalibration_[iJoyStick].negativeCoeff[i] = 1.0f/32767.0f;
-                joySticksCalibration_[iJoyStick].positiveCoeff[i] = 1.0f/32768.0f;
-                joySticksCalibration_[iJoyStick].zeroStates[i] = 0;
-            }
-        }
+            // Generate some sort of execution unique id per joy stick
+            std::string id = "JoyStick_";
+            id += omni_cast<std::string>(joySticks_[iJoyStick]->getNumberOfComponents(OIS::OIS_Button))  + "_";
+            id += omni_cast<std::string>(joySticks_[iJoyStick]->getNumberOfComponents(OIS::OIS_Axis))    + "_";
+            id += omni_cast<std::string>(joySticks_[iJoyStick]->getNumberOfComponents(OIS::OIS_Slider))  + "_";
+            id += omni_cast<std::string>(joySticks_[iJoyStick]->getNumberOfComponents(OIS::OIS_POV))     + "_";
+            id += omni_cast<std::string>(joySticks_[iJoyStick]->getNumberOfComponents(OIS::OIS_Vector3)) + "_";
+            id += joySticks_[iJoyStick]->vendor();
+            for (unsigned int i = 0; i < iJoyStick; ++i)
+            {
+                if (id == joyStickIDs_[i])
+                {
+                    // Two joysticks are probably equal --> add the index as well
+                    id += "_" + omni_cast<std::string>(iJoyStick);
+                }
+            }
+            joyStickIDs_[iJoyStick] = id;
+
+            size_t axes = sliderAxes + (size_t)this->joySticks_[iJoyStick]->getNumberOfComponents(OIS::OIS_Axis);
+            loadCalibration(joyStickMinValues_[iJoyStick], id, "MinValue", axes, -32768);
+            loadCalibration(joyStickMaxValues_[iJoyStick], id, "MaxValue", axes,  32768);
+            loadCalibration(joyStickMiddleValues_[iJoyStick], id, "MiddleValue", axes,      0);
+        }
+
+        _evaluateCalibration();
 
         // state management
@@ -380 +442 @@
     }
 
-    /**
-    @brief
-        Sets the configurable values.
-        This mainly concerns joy stick calibrations.
-    */
-    void InputManager::setConfigValues()
-    {
-        if (joySticksSize_ > 0)
-        {
-            std::vector<double> coeffPos;
-            std::vector<double> coeffNeg;
-            std::vector<int> zero;
-            coeffPos.resize(24);
-            coeffNeg.resize(24);
-            zero.resize(24);
-            for (unsigned int i = 0; i < 24; i++)
-            {
-                coeffPos[i] =  1.0f/32767.0f;
-                coeffNeg[i] =  1.0f/32768.0f;
-                zero[i]     =  0;
-            }
-
-            ConfigValueContainer* cont = getIdentifier()->getConfigValueContainer("CoeffPos");
-            if (!cont)
-            {
-                cont = new ConfigValueContainer(ConfigFileType::Settings, getIdentifier(), getIdentifier()->getName(), "CoeffPos", coeffPos);
-                getIdentifier()->addConfigValueContainer("CoeffPos", cont);
-            }
-            cont->getValue(&coeffPos, this);
-
-            cont = getIdentifier()->getConfigValueContainer("CoeffNeg");
-            if (!cont)
-            {
-                cont = new ConfigValueContainer(ConfigFileType::Settings, getIdentifier(), getIdentifier()->getName(), "CoeffNeg", coeffNeg);
-                getIdentifier()->addConfigValueContainer("CoeffNeg", cont);
-            }
-            cont->getValue(&coeffNeg, this);
-
-            cont = getIdentifier()->getConfigValueContainer("Zero");
-            if (!cont)
-            {
-                cont = new ConfigValueContainer(ConfigFileType::Settings, getIdentifier(), getIdentifier()->getName(), "Zero", zero);
-                getIdentifier()->addConfigValueContainer("Zero", cont);
-            }
-            cont->getValue(&zero, this);
-
-            // copy values to our own variables
-            for (unsigned int i = 0; i < 24; i++)
-            {
-                joySticksCalibration_[0].positiveCoeff[i] = coeffPos[i];
-                joySticksCalibration_[0].negativeCoeff[i] = coeffNeg[i];
-                joySticksCalibration_[0].zeroStates[i]    = zero[i];
-            }
-        }
-    }
-
+    void InputManager::_evaluateCalibration()
+    {
+        for (unsigned int iJoyStick = 0; iJoyStick < this->joySticksSize_; ++iJoyStick)
+        {
+            for (unsigned int i = 0; i < this->joyStickMinValues_[iJoyStick].size(); i++)
+            {
+                this->joyStickCalibrations_[iJoyStick].middleValue[i] = this->joyStickMiddleValues_[iJoyStick][i];
+                this->joyStickCalibrations_[iJoyStick].negativeCoeff[i] = - 1.0f / (this->joyStickMinValues_[iJoyStick][i] - this->joyStickMiddleValues_[iJoyStick][i]);
+                this->joyStickCalibrations_[iJoyStick].positiveCoeff[i] =   1.0f / (this->joyStickMaxValues_[iJoyStick][i] - this->joyStickMiddleValues_[iJoyStick][i]);
+            }
+        }
+    }
+    
+    void InputManager::_startCalibration()
+    {
+        for (unsigned int iJoyStick = 0; iJoyStick < this->joySticksSize_; ++iJoyStick)
+        {
+            // Set initial values
+            for (unsigned int i = 0; i < this->joyStickMinValues_[iJoyStick].size(); ++i)
+                this->joyStickMinValues_[iJoyStick][i] = INT_MAX;
+            for (unsigned int i = 0; i < this->joyStickMaxValues_[iJoyStick].size(); ++i)
+                this->joyStickMaxValues_[iJoyStick][i] = INT_MIN;
+            for (unsigned int i = 0; i < this->joyStickMiddleValues_[iJoyStick].size(); ++i)
+                this->joyStickMiddleValues_[iJoyStick][i] = 0;
+        }
+
+        getInstance().internalState_ |= Calibrating;
+        getInstance().requestEnterState("calibrator");
+    }
+
+    void InputManager::_completeCalibration()
+    {
+        for (unsigned int iJoyStick = 0; iJoyStick < this->joySticksSize_; ++iJoyStick)
+        {
+            // Get the middle positions now
+            unsigned int iAxis = 0;
+            for (unsigned int i = 0; i < sliderAxes/2; ++i)
+            {
+                this->joyStickMiddleValues_[iJoyStick][iAxis++] = this->joySticks_[iJoyStick]->getJoyStickState().mSliders[i].abX;
+                this->joyStickMiddleValues_[iJoyStick][iAxis++] = this->joySticks_[iJoyStick]->getJoyStickState().mSliders[i].abY;
+            }
+            // Note: joyStickMiddleValues_[iJoyStick] was already correctly resized in _configureJoySticks()
+            assert(joySticks_[iJoyStick]->getJoyStickState().mAxes.size() == joyStickMiddleValues_[iJoyStick].size() - sliderAxes);
+            for (unsigned int i = 0; i < joyStickMiddleValues_[iJoyStick].size() - sliderAxes; ++i)
+            {
+                this->joyStickMiddleValues_[iJoyStick][iAxis++] = this->joySticks_[iJoyStick]->getJoyStickState().mAxes[i].abs;
+            }
+
+            for (unsigned int i = 0; i < joyStickMinValues_[iJoyStick].size(); ++i)
+            {
+                // Minimum values
+                if (joyStickMinValues_[iJoyStick][i] == INT_MAX)
+                    joyStickMinValues_[iJoyStick][i] = -32768;
+                ConfigFileManager::getInstance().setValue(ConfigFileType::JoyStickCalibration,
+                    this->joyStickIDs_[iJoyStick], "MinValue", i, omni_cast<std::string>(joyStickMinValues_[iJoyStick][i]), false);
+
+                // Maximum values
+                if (joyStickMaxValues_[iJoyStick][i] == INT_MIN)
+                    joyStickMaxValues_[iJoyStick][i] = 32767;
+                ConfigFileManager::getInstance().setValue(ConfigFileType::JoyStickCalibration,
+                    this->joyStickIDs_[iJoyStick], "MaxValue", i, omni_cast<std::string>(joyStickMaxValues_[iJoyStick][i]), false);
+
+                // Middle values
+                ConfigFileManager::getInstance().setValue(ConfigFileType::JoyStickCalibration,
+                    this->joyStickIDs_[iJoyStick], "MiddleValue", i, omni_cast<std::string>(joyStickMiddleValues_[iJoyStick][i]), false);
+            }
+        }
+
+        _evaluateCalibration();
+
+        // restore old input state
+        requestLeaveState("calibrator");
+        internalState_ &= ~Calibrating;
+    }
 
     // ############################################################
@@ -492 +572 @@
             }
         }
-        singletonRef_s = 0;
+
+        singletonRef_s = 0;
     }
 
@@ -660 +741 @@
     /**
     @brief
-        Updates the InputManager. Tick is called by the Core class.
+        Updates the states and the InputState situation.
     @param dt
         Delta time
@@ -676 +757 @@
 
         // check for states to leave
-        for (std::set<InputState*>::reverse_iterator rit = stateLeaveRequests_.rbegin();
-            rit != stateLeaveRequests_.rend(); ++rit)
-        {
-            (*rit)->onLeave();
-            // just to be sure that the state actually is registered
-            assert(inputStatesByName_.find((*rit)->getName()) != inputStatesByName_.end());
-
-            activeStates_.erase((*rit)->getPriority());
-            _updateActiveStates();
-        }
-        stateLeaveRequests_.clear();
+        if (!stateLeaveRequests_.empty())
+        {
+            for (std::set<InputState*>::reverse_iterator rit = stateLeaveRequests_.rbegin();
+                rit != stateLeaveRequests_.rend(); ++rit)
+            {
+                (*rit)->onLeave();
+                // just to be sure that the state actually is registered
+                assert(inputStatesByName_.find((*rit)->getName()) != inputStatesByName_.end());
+
+                activeStates_.erase((*rit)->getPriority());
+                _updateActiveStates();
+            }
+            stateLeaveRequests_.clear();
+        }
 
         // check for states to enter
-        for (std::set<InputState*>::reverse_iterator rit = stateEnterRequests_.rbegin();
-            rit != stateEnterRequests_.rend(); ++rit)
-        {
-            // just to be sure that the state actually is registered
-            assert(inputStatesByName_.find((*rit)->getName()) != inputStatesByName_.end());
-
-            activeStates_[(*rit)->getPriority()] = (*rit);
-            _updateActiveStates();
-            (*rit)->onEnter();
-        }
-        stateEnterRequests_.clear();
+        if (!stateEnterRequests_.empty())
+        {
+            for (std::set<InputState*>::reverse_iterator rit = stateEnterRequests_.rbegin();
+                rit != stateEnterRequests_.rend(); ++rit)
+            {
+                // just to be sure that the state actually is registered
+                assert(inputStatesByName_.find((*rit)->getName()) != inputStatesByName_.end());
+
+                activeStates_[(*rit)->getPriority()] = (*rit);
+                _updateActiveStates();
+                (*rit)->onEnter();
+            }
+            stateEnterRequests_.clear();
+        }
 
         // check for states to destroy
-        for (std::set<InputState*>::reverse_iterator rit = stateDestroyRequests_.rbegin();
-            rit != stateDestroyRequests_.rend(); ++rit)
-        {
-            _destroyState((*rit));
-        }
-        stateDestroyRequests_.clear();
+        if (!stateDestroyRequests_.empty())
+        {
+            for (std::set<InputState*>::reverse_iterator rit = stateDestroyRequests_.rbegin();
+                rit != stateDestroyRequests_.rend(); ++rit)
+            {
+                _destroyState((*rit));
+            }
+            stateDestroyRequests_.clear();
+        }
 
         // check whether a state has changed its EMPTY_HANDLER situation
@@ -733 +823 @@
             joySticks_[i]->capture();
 
-        if (!bCalibrating_)
+        if (!(internalState_ & Calibrating))
         {
             // call all the handlers for the held key events
@@ -804 +894 @@
     /**
     @brief
-        Processes the accumultated data for the joy stick calibration.
-    */
-    void InputManager::_completeCalibration()
-    {
-        for (unsigned int i = 0; i < 24; i++)
-        {
-            // positive coefficient
-            if (marginalsMax_[i] == INT_MIN)
-                marginalsMax_[i] =  32767;
-            // coefficients
-            if (marginalsMax_[i] - joySticksCalibration_[0].zeroStates[i])
-            {
-                joySticksCalibration_[0].positiveCoeff[i]
-                    = 1.0f/(marginalsMax_[i] - joySticksCalibration_[0].zeroStates[i]);
-            }
-            else
-                joySticksCalibration_[0].positiveCoeff[i] =  1.0f;
-
-            // config value
-            ConfigValueContainer* cont = getIdentifier()->getConfigValueContainer("CoeffPos");
-            assert(cont);
-            cont->set(i, joySticksCalibration_[0].positiveCoeff[i]);
-
-            // negative coefficient
-            if (marginalsMin_[i] == INT_MAX)
-                marginalsMin_[i] = -32768;
-            // coefficients
-            if (marginalsMin_[i] - joySticksCalibration_[0].zeroStates[i])
-            {
-                joySticksCalibration_[0].negativeCoeff[i] = -1.0f
-                    / (marginalsMin_[i] - joySticksCalibration_[0].zeroStates[i]);
-            }
-            else
-                joySticksCalibration_[0].negativeCoeff[i] =  1.0f;
-            // config value
-            cont = getIdentifier()->getConfigValueContainer("CoeffNeg");
-            assert(cont);
-            cont->set(i, joySticksCalibration_[0].negativeCoeff[i]);
-
-            // zero states
-            if (i < 8)
-            {
-                if (!(i & 1))
-                    joySticksCalibration_[0].zeroStates[i] = joySticks_[0]->getJoyStickState().mSliders[i/2].abX;
-                else
-                    joySticksCalibration_[0].zeroStates[i] = joySticks_[0]->getJoyStickState().mSliders[i/2].abY;
-            }
-            else
-            {
-                if (i - 8 < joySticks_[0]->getJoyStickState().mAxes.size())
-                    joySticksCalibration_[0].zeroStates[i] = joySticks_[0]->getJoyStickState().mAxes[i - 8].abs;
-                else
-                    joySticksCalibration_[0].zeroStates[i] = 0;
-            }
-            // config value
-            cont = getIdentifier()->getConfigValueContainer("Zero");
-            assert(cont);
-            cont->set(i, joySticksCalibration_[0].zeroStates[i]);
-        }
-
-        // restore old input state
-        requestLeaveState("calibrator");
-        bCalibrating_ = false;
-    }
-
+        Clears all buffers that store what keys/buttons are being pressed at the moment.
+    */
     void InputManager::clearBuffers()
     {
@@ -1099 +1126 @@
     void InputManager::_fireAxis(unsigned int iJoyStick, int axis, int value)
     {
-        if (bCalibrating_)
-        {
-            if (value > marginalsMax_[axis])
-                marginalsMax_[axis] = value;
-            if (value < marginalsMin_[axis])
-                marginalsMin_[axis] = value;
+        if (internalState_ & Calibrating)
+        {
+            if (value < joyStickMinValues_[iJoyStick][axis])
+                joyStickMinValues_[iJoyStick][axis] = value;
+            if (value > joyStickMaxValues_[iJoyStick][axis])
+                joyStickMaxValues_[iJoyStick][axis] = value;
         }
         else
         {
-            float fValue = value - joySticksCalibration_[iJoyStick].zeroStates[axis];
+            float fValue = value - joyStickCalibrations_[iJoyStick].middleValue[axis];
             if (fValue > 0.0f)
-                fValue *= joySticksCalibration_[iJoyStick].positiveCoeff[axis];
+                fValue *= joyStickCalibrations_[iJoyStick].positiveCoeff[axis];
             else
-                fValue *= joySticksCalibration_[iJoyStick].negativeCoeff[axis];
+                fValue *= joyStickCalibrations_[iJoyStick].negativeCoeff[axis];
 
             activeStatesTop_[2 + iJoyStick]->joyStickAxisMoved(iJoyStick, axis, fValue);
@@ -1124 +1151 @@
 
         // keep in mind that the first 8 axes are reserved for the sliders
-        _fireAxis(iJoyStick, axis + 8, arg.state.mAxes[axis].abs);
+        _fireAxis(iJoyStick, axis + sliderAxes, arg.state.mAxes[axis].abs);
 
         return true;
@@ -1390 +1417 @@
     void InputManager::calibrate()
     {
-        getInstance().bCalibrating_ = true;
-        getInstance().requestEnterState("calibrator");
+        COUT(0) << "Move all joy stick axes fully in all directions." << std::endl
+                << "When done, put the axex in the middle position and press enter." << std::endl;
+
+        getInstance()._startCalibration();
     }
 

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

@@ -71 +71 @@
     struct JoyStickCalibration
     {
-        int zeroStates[24];
+        int middleValue[24];
         float positiveCoeff[24];
         float negativeCoeff[24];
@@ -136 +136 @@
     public: // variables
         static EmptyHandler                 EMPTY_HANDLER;
+        static const unsigned int           sliderAxes = 8;
 
     private: // functions
@@ -145 +146 @@
         void _initialiseMouse();
         void _initialiseJoySticks();
-        void _configureNumberOfJoySticks();
+        void _configureJoySticks();
+
+        void _loadCalibration();
+        void _startCalibration();
+        void _completeCalibration();
+        void _evaluateCalibration();
 
         void _destroyKeyboard();
@@ -154 +160 @@
 
         void _reload(bool joyStickSupport);
-
-        void _completeCalibration();
 
         void _fireAxis(unsigned int iJoyStick, int axis, int value);
@@ -178 +182 @@
 
         void setConfigValues();
+        void _calibrationFileCallback();
 
     private: // variables
@@ -185 +190 @@
         std::vector<OIS::JoyStick*>         joySticks_;            //!< OIS joy sticks
         unsigned int                        joySticksSize_;
+        std::vector<std::string>            joyStickIDs_;          //!< Execution unique identification strings for the joy sticks
         unsigned int                        devicesNum_;
         size_t                              windowHnd_;            //!< Render window handle
@@ -192 +198 @@
         SimpleInputState*                   stateEmpty_;
         ExtendedInputState*                 stateMaster_;          //!< Always active master input state
-        KeyDetector*                        keyDetector_;        //!< KeyDetector instance
+        KeyDetector*                        keyDetector_;          //!< KeyDetector instance
         InputBuffer*                        calibratorCallbackBuffer_;
 
@@ -207 +213 @@
 
         // joystick calibration
-        //std::vector<int> marginalsMaxConfig_;
-        //std::vector<int> marginalsMinConfig_;
-        int                                 marginalsMax_[24];
-        int                                 marginalsMin_[24];
-        bool                                bCalibrated_;
-        bool                                bCalibrating_;
+        std::vector<std::vector<int> >      joyStickMinValues_;
+        std::vector<std::vector<int> >      joyStickMaxValues_;
+        std::vector<std::vector<int> >      joyStickMiddleValues_;
+        std::vector<ConfigValueContainer*>  calibrationConfigValueContainers_;
+        std::vector<JoyStickCalibration>    joyStickCalibrations_; 
 
         unsigned int                        keyboardModifiers_;    //!< Bit mask representing keyboard modifiers.
         std::vector<POVStates>              povStates_;            //!< Keeps track of the joy stick POV states.
         std::vector<SliderStates>           sliderStates_;         //!< Keeps track of the possibly two slider axes.
-        std::vector<JoyStickCalibration>    joySticksCalibration_; 
 
         std::vector<Key>                    keysDown_;
@@ -223 +227 @@
         std::vector<std::vector<JoyStickButtonCode::ByEnum> >  joyStickButtonsDown_;
 
-        static std::string                  bindingCommmandString_s;
+        // ConfigValues
+        std::string                         calibrationFilename_;  //!< Joy stick calibration ini filename
+
         static InputManager*                singletonRef_s;
     };

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

@@ -33 +33 @@
 
 #include "KeyBinder.h"
+
 #include <fstream>
 #include <string>
+
 #include "util/Convert.h"
 #include "util/Debug.h"
@@ -66 +68 @@
             std::string keyname = KeyCode::ByString[i];
             if (!keyname.empty())
-            {
                 keys_[i].name_ = std::string("Key") + keyname;
-            }
             else
-            {
-                // some keys have name "" because the code is not occupied by OIS
-                // Use "Key_" plus the number as name to put it at the end of the config file section
-                std::string number = convertToString(i);
-                if (i < 100)
-                    number.insert(0, "0");
-                keys_[i].name_ = std::string("Key_") + number;
-            }
+                keys_[i].name_ = "";
             keys_[i].paramCommandBuffer_ = &paramCommandBuffer_;
             keys_[i].groupName_ = "Keys";
@@ -97 +90 @@
         for (unsigned int i = 0; i < MouseAxisCode::numberOfAxes * 2; i++)
         {
-            mouseAxes_[i].name_ = std::string("Mouse") + MouseAxisCode::ByString[i >> 1];
+            mouseAxes_[i].name_ = std::string("Mouse") + MouseAxisCode::ByString[i / 2];
             if (i & 1)
                 mouseAxes_[i].name_ += "Pos";
@@ -224 +217 @@
         allHalfAxes_.clear();
 
+        // Note: Don't include the dummy keys which don't actually exist in OIS but have a number
         for (unsigned int i = 0; i < KeyCode::numberOfKeys; i++)
-            allButtons_[keys_[i].name_] = keys_ + i;
+            if (!keys_[i].name_.empty())
+                allButtons_[keys_[i].name_] = keys_ + i;
         for (unsigned int i = 0; i < numberOfMouseButtons_; i++)
             allButtons_[mouseButtons_[i].name_] = mouseButtons_ + i;
@@ -327 +322 @@
         if (bDeriveMouseInput_)
         {
-            // only update when derive dt has passed
+            // only update when derivation dt has passed
             if (deriveTime_ > derivePeriod_)
             {
                 for (int i = 0; i < 2; i++)
                 {
-                    if (mouseRelative_[i] > 0)
+                    if (mouseRelative_[i] < 0)
                     {
                         mouseAxes_[2*i + 0].absVal_
-                            =  mouseRelative_[i] / deriveTime_ * 0.0005 * mouseSensitivityDerived_;
+                            = -mouseRelative_[i] / deriveTime_ * 0.0005 * mouseSensitivityDerived_;
                         mouseAxes_[2*i + 1].absVal_ = 0.0f;
                     }
-                    else if (mouseRelative_[i] < 0)
+                    else if (mouseRelative_[i] > 0)
                     {
                         mouseAxes_[2*i + 0].absVal_ = 0.0f;
                         mouseAxes_[2*i + 1].absVal_
-                            = -mouseRelative_[i] / deriveTime_ * 0.0005 * mouseSensitivityDerived_;
+                            =  mouseRelative_[i] / deriveTime_ * 0.0005 * mouseSensitivityDerived_;
                     }
                     else
@@ -363 +358 @@
             // Why dividing relative value by dt? The reason lies in the simple fact, that when you
             // press a button that has relative movement, that value has to be multiplied by dt to be
-            // frame rate independant. This can easily (and only) be done in tickInput(float).
+            // frame rate independent. This can easily (and only) be done in tickInput(float).
             // Hence we need to divide by dt here for the mouse to compensate, because the relative
             // move movements have nothing to do with dt.
@@ -441 +436 @@
             for (int i = 0; i < 2; i++)
             {
-                if (rel[i]) // performance opt. if rel[i] == 0
+                if (rel[i]) // performance opt. for the case that rel[i] == 0
                 {
                     // write absolute values
@@ -454 +449 @@
                         mousePosition_[i] = -mouseClippingSize_;
 
-                    if (mousePosition_[i] >= 0)
+                    if (mousePosition_[i] < 0)
                     {
-                        mouseAxes_[2*i + 0].absVal_ =   mousePosition_[i]/(float)mouseClippingSize_ * mouseSensitivity_;
+                        mouseAxes_[2*i + 0].absVal_ =  -mousePosition_[i]/(float)mouseClippingSize_ * mouseSensitivity_;
                         mouseAxes_[2*i + 1].absVal_ =  0.0f;
                     }
@@ -462 +457 @@
                     {
                         mouseAxes_[2*i + 0].absVal_ =  0.0f;
-                        mouseAxes_[2*i + 1].absVal_ =  -mousePosition_[i]/(float)mouseClippingSize_ * mouseSensitivity_;
+                        mouseAxes_[2*i + 1].absVal_ =   mousePosition_[i]/(float)mouseClippingSize_ * mouseSensitivity_;
                     }
                 }
@@ -471 +466 @@
         for (int i = 0; i < 2; i++)
         {
-            if (rel[i] > 0)
-                mouseAxes_[0 + 2*i].relVal_ =  ((float)rel[i])/(float)mouseClippingSize_ * mouseSensitivity_;
+            if (rel[i] < 0)
+                mouseAxes_[0 + 2*i].relVal_ = -((float)rel[i])/(float)mouseClippingSize_ * mouseSensitivity_;
             else
-                mouseAxes_[1 + 2*i].relVal_ = -((float)rel[i])/(float)mouseClippingSize_ * mouseSensitivity_;
+                mouseAxes_[1 + 2*i].relVal_ =  ((float)rel[i])/(float)mouseClippingSize_ * mouseSensitivity_;
         }
     }
@@ -484 +479 @@
     void KeyBinder::mouseScrolled(int abs, int rel)
     {
-        if (rel > 0)
-            for (int i = 0; i < rel/mouseWheelStepSize_; i++)
+        if (rel < 0)
+            for (int i = 0; i < -rel/mouseWheelStepSize_; i++)
                 mouseButtons_[8].execute(KeybindMode::OnPress, ((float)abs)/mouseWheelStepSize_);
         else
-            for (int i = 0; i < -rel/mouseWheelStepSize_; i++)
+            for (int i = 0; i < rel/mouseWheelStepSize_; i++)
                 mouseButtons_[9].execute(KeybindMode::OnPress, ((float)abs)/mouseWheelStepSize_);
     }
@@ -495 +490 @@
     {
         int i = axis * 2;
-        if (value >= 0)
-        {
-            joyStickAxes_[joyStickID][i].absVal_ = value;
-            joyStickAxes_[joyStickID][i].relVal_ = value;
+        if (value < 0)
+        {
+            joyStickAxes_[joyStickID][i].absVal_ = -value;
+            joyStickAxes_[joyStickID][i].relVal_ = -value;
             joyStickAxes_[joyStickID][i].hasChanged_ = true;
             if (joyStickAxes_[joyStickID][i + 1].absVal_ > 0.0f)
@@ -509 +504 @@
         else
         {
-            joyStickAxes_[joyStickID][i + 1].absVal_ = -value;
-            joyStickAxes_[joyStickID][i + 1].relVal_ = -value;
+            joyStickAxes_[joyStickID][i + 1].absVal_ = value;
+            joyStickAxes_[joyStickID][i + 1].relVal_ = value;
             joyStickAxes_[joyStickID][i + 1].hasChanged_ = true;
             if (joyStickAxes_[joyStickID][i].absVal_ > 0.0f)

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

@@ -39 +39 @@
 
 #include <vector>
+#include <cassert>
+
 #include "InputInterfaces.h"
 #include "Button.h"
@@ -44 +46 @@
 #include "InputCommands.h"
 #include "JoyStickDeviceNumberListener.h"
-#include "core/ConfigFileManager.h"
 
 namespace orxonox
@@ -171 +172 @@
 
     inline void KeyBinder::keyPressed (const KeyEvent& evt)
-    { keys_[evt.key].execute(KeybindMode::OnPress); }
+    { assert(!keys_[evt.key].name_.empty()); keys_[evt.key].execute(KeybindMode::OnPress); }
 
     inline void KeyBinder::keyReleased(const KeyEvent& evt)
-    { keys_[evt.key].execute(KeybindMode::OnRelease); }
+    { assert(!keys_[evt.key].name_.empty()); keys_[evt.key].execute(KeybindMode::OnRelease); }
 
     inline void KeyBinder::keyHeld    (const KeyEvent& evt)
-    { keys_[evt.key].execute(KeybindMode::OnHold); }
+    { assert(!keys_[evt.key].name_.empty()); keys_[evt.key].execute(KeybindMode::OnHold); }