Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 1293 for code/trunk/src/core


Ignore:
Timestamp:
May 15, 2008, 5:44:55 PM (17 years ago)
Author:
scheusso
Message:

merged changes from input & camera & network branch into trunk

Location:
code/trunk/src/core
Files:
19 edited
1 copied

Legend:

Unmodified
Added
Removed
  • code/trunk/src/core/BaseObject.cc

    r1209 r1293  
    4545        @brief Constructor: Registers the object in the BaseObject-list.
    4646    */
    47     BaseObject::BaseObject()
     47    BaseObject::BaseObject() :
     48      bActive_(true),
     49      bVisible_(true),
     50      level_(0),
     51      namespace_(0)
    4852    {
    4953        RegisterRootObject(BaseObject);
    50 
    51         this->bActive_ = true;
    52         this->bVisible_ = true;
    53         this->level_ = 0;
    54         this->namespace_ = 0;
    5554    }
    5655
  • code/trunk/src/core/CommandExecutor.h

    r1214 r1293  
    8989            inline std::string getAdditionalParameter() const
    9090                { return (this->additionalParameter_ != "") ? (" " + this->additionalParameter_) : ""; }
     91            inline std::string getCommandString() const { return this->processedCommand_; }
    9192
    9293            void setEvaluatedParameter(unsigned int index, MultiTypeMath param);
  • code/trunk/src/core/CoreIncludes.h

    r1062 r1293  
    5959    if (orxonox::Identifier::isCreatingHierarchy() && this->getParents()) \
    6060        this->getParents()->insert(this->getParents()->end(), this->getIdentifier()); \
    61     orxonox::ClassManager<ClassName>::getIdentifier()->addObject(this)
     61    orxonox::ClassManager<ClassName>::getIdentifier()->addObject(this); \
     62    if (orxonox::Identifier::isCreatingHierarchy()) \
     63      return
    6264
    6365/**
  • code/trunk/src/core/CorePrereqs.h

    r1219 r1293  
    144144
    145145  // input
     146  //class GUIInputHandler;
    146147  class InputBuffer;
    147148  class InputBufferListener;
    148149  class InputManager;
     150  class JoyStickHandler;
    149151  class KeyBinder;
    150   class GUIInputHandler;
    151152  class KeyHandler;
    152153  class MouseHandler;
    153   class JoyStickHandler;
    154154
    155155}
  • code/trunk/src/core/Debug.h

    r1219 r1293  
    273273#define CCOUT_EXEC(x) \
    274274  orxonox::OutputHandler::getOutStream().setOutputLevel(x) \
    275   << "*** " << this->getIdentifier()->getName() << ": "
     275  << this->getIdentifier()->getName() << ": "
    276276
    277277#ifndef CCOUT
  • code/trunk/src/core/Error.cc

    r1062 r1293  
    3737namespace orxonox
    3838{
    39         Error::Error()
    40         {
    41                 Error(0,"");
    42         }
    43 
    4439        Error::Error(std::string errorMsg, int errorCode)
    45         {
    46                 Error(errorCode, errorMsg);
    47         }
    48 
    49         Error::Error(int errorCode, std::string errorMsg)
    5040        {
    5141                COUT(1) << "############################ "<< std::endl
  • code/trunk/src/core/Error.h

    r1062 r1293  
    4444        {
    4545        public:
    46                 Error();
    47                 Error(std::string errorMsg, int errorCode = 0);
    48                 Error(int errorCode, std::string errorMsg = "");
     46                Error(std::string errorMsg = "", int errorCode = 0);
    4947        private:
    5048
  • code/trunk/src/core/InputBuffer.cc

    r1220 r1293  
    2323 *      Fabian 'x3n' Landau
    2424 *   Co-authors:
    25  *      ...
     25 *      Reto Grieder
    2626 *
    2727 */
     
    3232
    3333#include "util/Clipboard.h"
    34 #include "InputManager.h"
     34#include "CoreIncludes.h"
     35#include "ConfigValueIncludes.h"
    3536
    3637namespace orxonox
    3738{
    38     InputBuffer::InputBuffer()
    39     {
    40         //this->bActivated_ = false;
    41         this->allowedChars_ = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZäöüÄÖÜ0123456789 \\\"(){}[]<>.:,;_-+*/=!?|$&%^";
    42         this->keyboard_ = InputManager::getKeyboard();
    43         this->buffer_ = "";
    44 
    45         //this->keyboard_->setEventCallback(this);
    46     }
    47 
    48     InputBuffer::InputBuffer(const std::string allowedChars)
    49     {
    50         //this->bActivated_ = false;
    51         this->allowedChars_ = allowedChars;
    52         this->keyboard_ = InputManager::getKeyboard();
    53         this->buffer_ = "";
    54     }
    55 /*
    56     void InputBuffer::registerListener(InputBufferListener* listener, void (InputBufferListener::*function)(), bool bOnlySingleInput)
    57     {
    58         struct InputBufferListenerTuple newListener = {listener, function, true, bOnlySingleInput, ' '};
    59         this->listeners_.insert(this->listeners_.end(), newListener);
    60     }
    61 
    62     void InputBuffer::registerListener(InputBufferListener* listener, void (InputBufferListener::*function)(), char char_, bool bOnlySingleInput)
    63     {
    64         struct InputBufferListenerTuple newListener = {listener, function, false, bOnlySingleInput, char_};
    65         this->listeners_.insert(this->listeners_.end(), newListener);
    66     }
    67 */
    68     void InputBuffer::set(const std::string& input)
    69     {
    70         this->buffer_ = "";
    71         this->append(input);
    72     }
    73 
    74     void InputBuffer::append(const std::string& input)
    75     {
    76         for (unsigned int i = 0; i < input.size(); i++)
    77         {
    78             if (this->charIsAllowed(input[i]))
    79                 this->buffer_ += input[i];
    80 
    81             this->updated(input[i], false);
    82         }
    83         this->updated();
    84     }
    85 
    86     void InputBuffer::append(const char& input)
    87     {
    88         if (this->charIsAllowed(input))
    89             this->buffer_ += input;
    90 
    91         this->updated(input, true);
    92     }
    93 
    94     void InputBuffer::clear()
    95     {
    96         this->buffer_ = "";
    97         this->updated();
    98     }
    99 
    100     void InputBuffer::removeLast()
    101     {
    102         this->buffer_ = this->buffer_.substr(0, this->buffer_.size() - 1);
    103         this->updated();
    104     }
    105 
    106     void InputBuffer::updated()
    107     {
    108         for (std::list<InputBufferListenerTuple>::iterator it = this->listeners_.begin(); it != this->listeners_.end(); ++it)
    109         {
    110             if ((*it).bListenToAllChanges_)
    111                 (*(*it).listener_.*(*it).function_)();
    112         }
    113     }
    114 
    115     void InputBuffer::updated(const char& update, bool bSingleInput)
    116     {
    117         for (std::list<InputBufferListenerTuple>::iterator it = this->listeners_.begin(); it != this->listeners_.end(); ++it)
    118         {
    119             if (((*it).bListenToAllChanges_ || ((*it).char_ == update)) && (!(*it).bOnlySingleInput_ || bSingleInput))
    120                 (*(*it).listener_.*(*it).function_)();
    121         }
    122     }
    123 
    124     /*void InputBuffer::activityChanged() const
    125     {
    126     }*/
    127 
    128     bool InputBuffer::charIsAllowed(const char& input)
    129     {
    130         if (this->allowedChars_ == "")
    131             return true;
    132         else
    133             return (this->allowedChars_.find(input) != std::string::npos);
    134     }
    135 
    136     bool InputBuffer::keyPressed(const OIS::KeyEvent &e)
    137     {
    138         /*if (e.key == OIS::KC_NUMPADENTER)
    139         {
    140             this->setActivated(!this->isActivated());
    141             this->clear();
    142             return true;
    143         }*/
    144 
    145         if (this->keyboard_->isModifierDown(OIS::Keyboard::Ctrl))
    146         {
    147             if (e.key == OIS::KC_V)
    148             {
    149                 this->append(fromClipboard());
    150                 return true;
    151             }
    152             else if (e.key == OIS::KC_C)
    153             {
    154                 toClipboard(this->buffer_);
    155                 return true;
    156             }
    157             else if (e.key == OIS::KC_X)
    158             {
    159                 toClipboard(this->buffer_);
    160                 this->clear();
    161                 return true;
    162             }
    163         }
    164         else if (this->keyboard_->isModifierDown(OIS::Keyboard::Shift))
    165         {
    166             if (e.key == OIS::KC_INSERT)
    167             {
    168                 this->append(fromClipboard());
    169                 return true;
    170             }
    171             else if (e.key == OIS::KC_DELETE)
    172             {
    173                 toClipboard(this->buffer_);
    174                 this->clear();
    175                 return true;
    176             }
    177         }
    178 
    179         //std::cout << this->keyboard_->getAsString(e.key) << " / " << (char)e.text << std::endl;
    180 
    181         std::string input = this->keyboard_->getAsString(e.key);
    182         /*if (input.size() >= 1)
    183             this->append(input[0]);*/
    184 
    185         this->append((char)e.text);
    186         return true;
    187     }
    188 
    189     bool InputBuffer::keyReleased(const OIS::KeyEvent &e)
    190     {
    191         return true;
    192     }
     39  InputBuffer::InputBuffer(const std::string allowedChars) :
     40    buffer_(""),
     41    allowedChars_(allowedChars),
     42    lastKey_(KeyCode::Unassigned),
     43    timeSinceKeyPressed_(0.0f),
     44    timeSinceKeyRepeated_(0.0f),
     45    keysToRepeat_(0)
     46  {
     47    RegisterObject(InputBuffer);
     48    setConfigValues();
     49  }
     50
     51  void InputBuffer::setConfigValues()
     52  {
     53    SetConfigValue(keyRepeatDeleay_, 0.4).description("Key repeat deleay of the input buffer");
     54    SetConfigValue(keyRepeatTime_, 0.022).description("Key repeat time of the input buffer");
     55    if (keyRepeatDeleay_ < 0.0)
     56    {
     57      ResetConfigValue(keyRepeatDeleay_);
     58    }
     59    if (keyRepeatTime_ < 0.0)
     60    {
     61      ResetConfigValue(keyRepeatTime_);
     62    }
     63  }
     64  /*
     65  void InputBuffer::registerListener(InputBufferListener* listener, void (InputBufferListener::*function)(), bool bOnlySingleInput)
     66  {
     67    struct InputBufferListenerTuple newListener = {listener, function, true, bOnlySingleInput, ' '};
     68    listeners_.insert(listeners_.end(), newListener);
     69  }
     70
     71  void InputBuffer::registerListener(InputBufferListener* listener, void (InputBufferListener::*function)(), char char_, bool bOnlySingleInput)
     72  {
     73    struct InputBufferListenerTuple newListener = {listener, function, false, bOnlySingleInput, char_};
     74    listeners_.insert(listeners_.end(), newListener);
     75  }
     76  */
     77  void InputBuffer::set(const std::string& input)
     78  {
     79    buffer_ = "";
     80    append(input);
     81  }
     82
     83  void InputBuffer::append(const std::string& input)
     84  {
     85    for (unsigned int i = 0; i < input.size(); i++)
     86    {
     87      if (charIsAllowed(input[i]))
     88        buffer_ += input[i];
     89
     90      updated(input[i], false);
     91    }
     92    updated();
     93  }
     94
     95  void InputBuffer::append(const char& input)
     96  {
     97    if (charIsAllowed(input))
     98      buffer_ += input;
     99
     100    updated(input, true);
     101  }
     102
     103  void InputBuffer::clear()
     104  {
     105    buffer_ = "";
     106    updated();
     107  }
     108
     109  void InputBuffer::removeLast()
     110  {
     111    buffer_ = buffer_.substr(0, buffer_.size() - 1);
     112    updated();
     113  }
     114
     115  void InputBuffer::updated()
     116  {
     117    for (std::list<InputBufferListenerTuple>::iterator it = listeners_.begin(); it != listeners_.end(); ++it)
     118    {
     119      if ((*it).bListenToAllChanges_)
     120        (*(*it).listener_.*(*it).function_)();
     121    }
     122  }
     123
     124  void InputBuffer::updated(const char& update, bool bSingleInput)
     125  {
     126    for (std::list<InputBufferListenerTuple>::iterator it = listeners_.begin(); it != listeners_.end(); ++it)
     127    {
     128      if (((*it).bListenToAllChanges_ || ((*it).char_ == update)) && (!(*it).bOnlySingleInput_ || bSingleInput))
     129        (*(*it).listener_.*(*it).function_)();
     130    }
     131  }
     132
     133  bool InputBuffer::charIsAllowed(const char& input)
     134  {
     135    if (allowedChars_ == "")
     136      return true;
     137    else
     138      return (allowedChars_.find(input) != std::string::npos);
     139  }
     140
     141
     142  void InputBuffer::processKey(const KeyEvent &evt)
     143  {
     144    if (evt.isModifierDown(KeyboardModifier::Ctrl))
     145    {
     146      if (evt.key == KeyCode::V)
     147        append(fromClipboard());
     148      else if (evt.key == KeyCode::C)
     149        toClipboard(buffer_);
     150      else if (evt.key == KeyCode::X)
     151      {
     152        toClipboard(buffer_);
     153        clear();
     154      }
     155    }
     156    else if (evt.isModifierDown(KeyboardModifier::Shift))
     157    {
     158      if (evt.key == KeyCode::Insert)
     159      {
     160        append(fromClipboard());
     161      }
     162      else if (evt.key == KeyCode::Delete)
     163      {
     164        toClipboard(buffer_);
     165        clear();
     166      }
     167    }
     168    //std::string input = keyboard_->getAsString(e.key);
     169    /*if (input.size() >= 1)
     170    append(input[0]);*/
     171
     172    append((char)evt.text);
     173  }
     174
     175  void InputBuffer::tick(float dt)
     176  {
     177    timeSinceKeyPressed_ += dt;
     178    if (keysToRepeat_ < 10 && timeSinceKeyPressed_ > keyRepeatDeleay_)
     179    {
     180      // initial time out has gone by, start repeating keys
     181      while (timeSinceKeyPressed_ - timeSinceKeyRepeated_ > keyRepeatTime_)
     182      {
     183        timeSinceKeyRepeated_ += keyRepeatTime_;
     184        keysToRepeat_++;
     185      }
     186    }
     187  }
     188
     189  bool InputBuffer::keyPressed(const KeyEvent &evt)
     190  {
     191    lastKey_ = evt.key;
     192    timeSinceKeyPressed_ = 0.0;
     193    timeSinceKeyRepeated_ = keyRepeatDeleay_;
     194    keysToRepeat_ = 0;
     195
     196    processKey(evt);
     197    return true;
     198  }
     199
     200  bool InputBuffer::keyHeld(const KeyEvent& evt)
     201  {
     202    if (evt.key == lastKey_)
     203    {
     204      while (keysToRepeat_)
     205      {
     206        processKey(evt);
     207        keysToRepeat_--;
     208      }
     209    }
     210    return true;
     211  }
     212
    193213}
  • code/trunk/src/core/InputBuffer.h

    r1219 r1293  
    2323 *      Fabian 'x3n' Landau
    2424 *   Co-authors:
    25  *      ...
     25 *      Reto Grieder
    2626 *
    2727 */
     
    3535#include <list>
    3636
    37 #include "ois/OISKeyboard.h"
    38 #include "InputHandler.h"
     37#include "InputInterfaces.h"
     38#include "Tickable.h"
    3939
    4040namespace orxonox
    4141{
    42     class _CoreExport InputBufferListener
    43     {};
     42  class _CoreExport InputBufferListener
     43  {};
    4444
    45     class _CoreExport InputBuffer : public KeyHandler
     45  class _CoreExport InputBuffer : public KeyHandler, public TickableReal
     46  {
     47    struct InputBufferListenerTuple
    4648    {
    47         struct InputBufferListenerTuple
    48         {
    49             InputBufferListener* listener_;
    50             void (InputBufferListener::*function_)();
    51             bool bListenToAllChanges_;
    52             bool bOnlySingleInput_;
    53             char char_;
    54         };
     49      InputBufferListener* listener_;
     50      void (InputBufferListener::*function_)();
     51      bool bListenToAllChanges_;
     52      bool bOnlySingleInput_;
     53      char char_;
     54    };
    5555
    56         public:
    57             InputBuffer();
    58             InputBuffer(const std::string allowedChars);
     56  public:
     57    InputBuffer(const std::string allowedChars =
     58      "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZäöüÄÖÜ0123456789 \\\"(){}[]<>.:,;_-+*/=!?|$&%^");
    5959
    60             template <class T>
    61             void registerListener(T* listener, void (T::*function)(), bool bOnlySingleInput)
    62             {
    63                 struct InputBufferListenerTuple newListener = {listener, (void (InputBufferListener::*)())function, true, bOnlySingleInput, ' '};
    64                 this->listeners_.insert(this->listeners_.end(), newListener);
    65             }
    66             template <class T>
    67             void registerListener(T* listener, void (T::*function)() const, bool bOnlySingleInput)
    68             {
    69                 struct InputBufferListenerTuple newListener = {listener, (void (InputBufferListener::*)())function, true, bOnlySingleInput, ' '};
    70                 this->listeners_.insert(this->listeners_.end(), newListener);
    71             }
     60    void setConfigValues();
    7261
    73             template <class T>
    74             void registerListener(T* listener, void (T::*function)(), char char_, bool bOnlySingleInput)
    75             {
    76                 struct InputBufferListenerTuple newListener = {listener, (void (InputBufferListener::*)())function, false, bOnlySingleInput, char_};
    77                 this->listeners_.insert(this->listeners_.end(), newListener);
    78             }
    79             template <class T>
    80             void registerListener(T* listener, void (T::*function)() const, char char_, bool bOnlySingleInput)
    81             {
    82                 struct InputBufferListenerTuple newListener = {listener, (void (InputBufferListener::*)())function, false, bOnlySingleInput, char_};
    83                 this->listeners_.insert(this->listeners_.end(), newListener);
    84             }
     62    template <class T>
     63    void registerListener(T* listener, void (T::*function)(), bool bOnlySingleInput)
     64    {
     65      struct InputBufferListenerTuple newListener = {listener, (void (InputBufferListener::*)())function, true, bOnlySingleInput, ' '};
     66      this->listeners_.insert(this->listeners_.end(), newListener);
     67    }
     68    template <class T>
     69    void registerListener(T* listener, void (T::*function)() const, bool bOnlySingleInput)
     70    {
     71      struct InputBufferListenerTuple newListener = {listener, (void (InputBufferListener::*)())function, true, bOnlySingleInput, ' '};
     72      this->listeners_.insert(this->listeners_.end(), newListener);
     73    }
    8574
    86             void set(const std::string& input);
    87             void append(const std::string& input);
    88             void append(const char& input);
    89             void removeLast();
    90             void clear();
     75    template <class T>
     76    void registerListener(T* listener, void (T::*function)(), char char_, bool bOnlySingleInput)
     77    {
     78      struct InputBufferListenerTuple newListener = {listener, (void (InputBufferListener::*)())function, false, bOnlySingleInput, char_};
     79      this->listeners_.insert(this->listeners_.end(), newListener);
     80    }
     81    template <class T>
     82    void registerListener(T* listener, void (T::*function)() const, char char_, bool bOnlySingleInput)
     83    {
     84      struct InputBufferListenerTuple newListener = {listener, (void (InputBufferListener::*)())function, false, bOnlySingleInput, char_};
     85      this->listeners_.insert(this->listeners_.end(), newListener);
     86    }
    9187
    92             void updated();
    93             void updated(const char& update, bool bSingleInput);
     88    void set(const std::string& input);
     89    void append(const std::string& input);
     90    void append(const char& input);
     91    void removeLast();
     92    void clear();
    9493
    95             inline std::string get() const
    96                 { return this->buffer_; }
     94    void updated();
     95    void updated(const char& update, bool bSingleInput);
    9796
    98             /*inline void activate()
    99                 { this->setActivated(true); }
    100             inline void deactivate()
    101                 { this->setActivated(false); }
    102             inline void setActivated(bool bActivated)
    103                 { if (this->bActivated_ != bActivated) { this->bActivated_ = bActivated; this->activityChanged(); } else { this->bActivated_ = bActivated; } }
    104             inline bool isActivated() const
    105                 { return this->bActivated_; }
     97    inline std::string get() const
     98    { return this->buffer_; }
    10699
    107             void activityChanged() const;*/
     100  private:  // functions
     101    bool charIsAllowed(const char& input);
    108102
    109         private:
    110             bool charIsAllowed(const char& input);
     103    bool keyPressed (const KeyEvent& evt);
     104    bool keyReleased(const KeyEvent& evt) { return true; }
     105    bool keyHeld    (const KeyEvent& evt);
     106    void processKey (const KeyEvent &e);
    111107
    112             bool keyPressed(const OIS::KeyEvent &e);
    113             bool keyReleased(const OIS::KeyEvent &e);
    114             bool keyHeld(const OIS::KeyEvent &e) { return true; }
     108    void tick(float dt);
    115109
    116             OIS::Keyboard* keyboard_;
    117             //bool bActivated_;
    118             std::string buffer_;
    119             std::list<InputBufferListenerTuple> listeners_;
    120             std::string allowedChars_;
    121     };
     110  private: // variables
     111    std::string buffer_;
     112    std::list<InputBufferListenerTuple> listeners_;
     113    std::string allowedChars_;
     114
     115    KeyCode::Enum lastKey_;
     116    float timeSinceKeyPressed_;
     117    float timeSinceKeyRepeated_;
     118    int keysToRepeat_;
     119
     120    // configured values
     121    float keyRepeatDeleay_;
     122    float keyRepeatTime_;
     123  };
    122124}
    123125
  • code/trunk/src/core/InputHandler.cc

    r1219 r1293  
    3333
    3434#include "InputHandler.h"
     35#include "util/Convert.h"
    3536#include "Debug.h"
    3637#include "ConfigValueIncludes.h"
    3738#include "CoreIncludes.h"
    38 #include "util/Convert.h"
    39 #include "core/CommandExecutor.h"
     39#include "CommandExecutor.h"
    4040
    4141namespace orxonox
     
    5555    std::string keyNames[] = {
    5656    "UNASSIGNED",
    57                 "ESCAPE",
    58                 "1",
    59                 "2",
    60                 "3",
    61                 "4",
    62                 "5",
    63                 "6",
    64                 "7",
    65                 "8",
    66                 "9",
    67                 "0",
    68                 "MINUS",
    69                 "EQUALS",
    70                 "BACK",
    71                 "TAB",
    72                 "Q",
    73                 "W",
    74                 "E",
    75                 "R",
    76                 "T",
    77                 "Y",
    78                 "U",
    79                 "I",
    80                 "O",
    81                 "P",
    82                 "LBRACKET",
    83                 "RBRACKET",
    84                 "RETURN",
    85                 "LCONTROL",
    86                 "A",
    87                 "S",
    88                 "D",
    89                 "F",
    90                 "G",
    91                 "H",
    92                 "J",
    93                 "K",
    94                 "L",
    95                 "SEMICOLON",
    96                 "APOSTROPHE",
    97                 "GRAVE",
    98                 "LSHIFT",
    99                 "BACKSLASH",
    100                 "Z",
    101                 "X",
    102                 "C",
    103                 "V",
    104                 "B",
    105                 "N",
    106                 "M",
    107                 "COMMA",
    108                 "PERIOD",
    109                 "SLASH",
    110                 "RSHIFT",
    111                 "MULTIPLY",
    112                 "LMENU",
    113                 "SPACE",
    114                 "CAPITAL",
    115                 "F1",
    116                 "F2",
    117                 "F3",
    118                 "F4",
    119                 "F5",
    120                 "F6",
    121                 "F7",
    122                 "F8",
    123                 "F9",
    124                 "F10",
    125                 "NUMLOCK",
    126                 "SCROLL",
    127                 "NUMPAD7",
    128                 "NUMPAD8",
    129                 "NUMPAD9",
    130                 "SUBTRACT",
    131                 "NUMPAD4",
    132                 "NUMPAD5",
    133                 "NUMPAD6",
    134                 "ADD",
    135                 "NUMPAD1",
    136                 "NUMPAD2",
    137                 "NUMPAD3",
    138                 "NUMPAD0",
    139                 "DECIMAL",
     57    "ESCAPE",
     58    "1",
     59    "2",
     60    "3",
     61    "4",
     62    "5",
     63    "6",
     64    "7",
     65    "8",
     66    "9",
     67    "0",
     68    "MINUS",
     69    "EQUALS",
     70    "BACK",
     71    "TAB",
     72    "Q",
     73    "W",
     74    "E",
     75    "R",
     76    "T",
     77    "Y",
     78    "U",
     79    "I",
     80    "O",
     81    "P",
     82    "LBRACKET",
     83    "RBRACKET",
     84    "RETURN",
     85    "LCONTROL",
     86    "A",
     87    "S",
     88    "D",
     89    "F",
     90    "G",
     91    "H",
     92    "J",
     93    "K",
     94    "L",
     95    "SEMICOLON",
     96    "APOSTROPHE",
     97    "GRAVE",
     98    "LSHIFT",
     99    "BACKSLASH",
     100    "Z",
     101    "X",
     102    "C",
     103    "V",
     104    "B",
     105    "N",
     106    "M",
     107    "COMMA",
     108    "PERIOD",
     109    "SLASH",
     110    "RSHIFT",
     111    "MULTIPLY",
     112    "LMENU",
     113    "SPACE",
     114    "CAPITAL",
     115    "F1",
     116    "F2",
     117    "F3",
     118    "F4",
     119    "F5",
     120    "F6",
     121    "F7",
     122    "F8",
     123    "F9",
     124    "F10",
     125    "NUMLOCK",
     126    "SCROLL",
     127    "NUMPAD7",
     128    "NUMPAD8",
     129    "NUMPAD9",
     130    "SUBTRACT",
     131    "NUMPAD4",
     132    "NUMPAD5",
     133    "NUMPAD6",
     134    "ADD",
     135    "NUMPAD1",
     136    "NUMPAD2",
     137    "NUMPAD3",
     138    "NUMPAD0",
     139    "DECIMAL",
    140140    "","",
    141                 "OEM_102",
    142                 "F11",
    143                 "F12",
     141    "OEM_102",
     142    "F11",
     143    "F12",
    144144    "","","","","","","","","","","",
    145                 "F13",
    146                 "F14",
    147                 "F15",
     145    "F13",
     146    "F14",
     147    "F15",
    148148    "","","","","","","","","","",
    149                 "KANA",
     149    "KANA",
    150150    "","",
    151                 "ABNT_C1",
     151    "ABNT_C1",
    152152    "","","","","",
    153                 "CONVERT",
    154     "",
    155                 "NOCONVERT",
    156     "",
    157                 "YEN",
    158                 "ABNT_C2",
     153    "CONVERT",
     154    "",
     155    "NOCONVERT",
     156    "",
     157    "YEN",
     158    "ABNT_C2",
    159159    "","","","","","","","","","","","","","",
    160                 "NUMPADEQUALS",
     160    "NUMPADEQUALS",
    161161    "","",
    162                 "PREVTRACK",
    163                 "AT",
    164                 "COLON",
    165                 "UNDERLINE",
    166                 "KANJI",
    167                 "STOP",
    168                 "AX",
    169                 "UNLABELED",
    170                 "NEXTTRACK",
     162    "PREVTRACK",
     163    "AT",
     164    "COLON",
     165    "UNDERLINE",
     166    "KANJI",
     167    "STOP",
     168    "AX",
     169    "UNLABELED",
     170    "NEXTTRACK",
    171171    "","",
    172                 "NUMPADENTER",
    173                 "RCONTROL",
     172    "NUMPADENTER",
     173    "RCONTROL",
    174174    "","",
    175                 "MUTE",
    176                 "CALCULATOR",
    177                 "PLAYPAUSE",
    178     "",
    179                 "MEDIASTOP",
     175    "MUTE",
     176    "CALCULATOR",
     177    "PLAYPAUSE",
     178    "",
     179    "MEDIASTOP",
    180180    "","","","","","","","","",
    181                 "VOLUMEDOWN",
    182     "",
    183                 "VOLUMEUP",
    184     "",
    185                 "WEBHOME",
    186                 "NUMPADCOMMA",
    187     "",
    188                 "DIVIDE",
    189     "",
    190                 "SYSRQ",
    191                 "RMENU",
     181    "VOLUMEDOWN",
     182    "",
     183    "VOLUMEUP",
     184    "",
     185    "WEBHOME",
     186    "NUMPADCOMMA",
     187    "",
     188    "DIVIDE",
     189    "",
     190    "SYSRQ",
     191    "RMENU",
    192192    "","","","","","","","","","","","",
    193                 "PAUSE",
    194     "",
    195                 "HOME",
    196                 "UP",
    197                 "PGUP",
    198     "",
    199                 "LEFT",
    200     "",
    201                 "RIGHT",
    202     "",
    203                 "END",
    204                 "DOWN",
    205                 "PGDOWN",
    206                 "INSERT",
    207                 "DELETE",
     193    "PAUSE",
     194    "",
     195    "HOME",
     196    "UP",
     197    "PGUP",
     198    "",
     199    "LEFT",
     200    "",
     201    "RIGHT",
     202    "",
     203    "END",
     204    "DOWN",
     205    "PGDOWN",
     206    "INSERT",
     207    "DELETE",
    208208    "","","","","","","",
    209                 "LWIN",
    210                 "RWIN",
    211                 "APPS",
    212                 "POWER",
    213                 "SLEEP",
     209    "LWIN",
     210    "RWIN",
     211    "APPS",
     212    "POWER",
     213    "SLEEP",
    214214    "","","",
    215                 "WAKE",
    216     "",
    217                 "WEBSEARCH",
    218                 "WEBFAVORITES",
    219                 "WEBREFRESH",
    220                 "WEBSTOP",
    221                 "WEBFORWARD",
    222                 "WEBBACK",
    223                 "MYCOMPUTER",
    224                 "MAIL",
    225                 "MEDIASELECT"
     215    "WAKE",
     216    "",
     217    "WEBSEARCH",
     218    "WEBFAVORITES",
     219    "WEBREFRESH",
     220    "WEBSTOP",
     221    "WEBFORWARD",
     222    "WEBBACK",
     223    "MYCOMPUTER",
     224    "MAIL",
     225    "MEDIASELECT"
    226226    };
    227227    for (int i = 0; i < numberOfKeys_s; i++)
     
    229229
    230230    std::string mouseButtonNames[] = {
    231     "MouseLeft", "MouseRight", "MouseMiddle",
    232     "MouseButton3", "MouseButton4", "MouseButton5",
    233     "MouseButton6", "MouseButton7" };
     231      "MouseLeft", "MouseRight", "MouseMiddle",
     232      "MouseButton3", "MouseButton4", "MouseButton5",
     233      "MouseButton6", "MouseButton7" };
    234234    for (int i = 0; i < numberOfMouseButtons_s; i++)
    235235      mouseButtonNames_[i] = mouseButtonNames[i];
     
    267267        switch (j)
    268268        {
    269           // note: the first element in the struct is the string, so the following pointer
    270           //       arithmetic works.
    271269          case 0:
    272270            cont->getValue(&bindingsKeyPress_[i].commandStr);
    273271            break;
    274272          case 1:
    275             cont->getValue(bindingsKeyRelease_ + i);
     273            cont->getValue(&bindingsKeyRelease_[i].commandStr);
    276274            break;
    277275          case 2:
    278             cont->getValue(bindingsKeyHold_ + i);
     276            cont->getValue(&bindingsKeyHold_[i].commandStr);
    279277        }
    280278      }
     
    295293        {
    296294          case 0:
    297             cont->getValue(bindingsMouseButtonPress_ + i);
     295            cont->getValue(&bindingsMouseButtonPress_[i].commandStr);
    298296            break;
    299297          case 1:
    300             cont->getValue(bindingsMouseButtonRelease_ + i);
     298            cont->getValue(&bindingsMouseButtonRelease_[i].commandStr);
    301299            break;
    302300          case 2:
    303             cont->getValue(bindingsMouseButtonHold_ + i);
     301            cont->getValue(&bindingsMouseButtonHold_[i].commandStr);
    304302        }
    305303      }
     
    320318        {
    321319          case 0:
    322             cont->getValue(bindingsJoyStickButtonPress_ + i);
     320            cont->getValue(&bindingsJoyStickButtonPress_[i].commandStr);
    323321            break;
    324322          case 1:
    325             cont->getValue(bindingsJoyStickButtonRelease_ + i);
     323            cont->getValue(&bindingsJoyStickButtonRelease_[i].commandStr);
    326324            break;
    327325          case 2:
    328             cont->getValue(bindingsJoyStickButtonHold_ + i);
     326            cont->getValue(&bindingsJoyStickButtonHold_[i].commandStr);
    329327        }
    330328      }
     
    345343    for (int i = 0; i < numberOfMouseButtons_s; i++)
    346344    {
    347       bindingsMouseButtonPress_  [i] = "";
    348       bindingsMouseButtonRelease_[i] = "";
    349       bindingsMouseButtonHold_   [i] = "";
     345      bindingsMouseButtonPress_  [i].commandStr = "";
     346      bindingsMouseButtonRelease_[i].commandStr = "";
     347      bindingsMouseButtonHold_   [i].commandStr = "";
    350348    }
    351349    for (int i = 0; i < numberOfJoyStickButtons_s; i++)
    352350    {
    353       bindingsJoyStickButtonPress_  [i] = "";
    354       bindingsJoyStickButtonRelease_[i] = "";
    355       bindingsJoyStickButtonHold_   [i] = "";
     351      bindingsJoyStickButtonPress_  [i].commandStr = "";
     352      bindingsJoyStickButtonRelease_[i].commandStr = "";
     353      bindingsJoyStickButtonHold_   [i].commandStr = "";
    356354    }
    357355  }
     
    370368    // evaluate the key bindings
    371369    // TODO: what if binding is invalid?
    372     //for (int i = 0; i < numberOfKeys_s; i++)
    373     //{
    374     //  if (bindingsKeyPress_[i].commandStr != "")
    375     //  {
    376     //    bindingsKeyPress_[i].evaluation = CommandExecutor::evaluate(bindingsKeyPress_[i].commandStr);
    377     //    bindingsKeyPress_[i].commandStr = bindingsKeyPress_[i].evaluation.getCommandString();
    378     //  }
    379     //}
     370    for (int i = 0; i < numberOfKeys_s; i++)
     371    {
     372      if (bindingsKeyPress_[i].commandStr != "")
     373      {
     374        bindingsKeyPress_[i].evaluation = CommandExecutor::evaluate(bindingsKeyPress_[i].commandStr);
     375        bindingsKeyPress_[i].commandStr = bindingsKeyPress_[i].evaluation.getCommandString();
     376      }
     377    }
    380378
    381379    COUT(ORX_DEBUG) << "KeyBinder: Loading key bindings done." << std::endl;
     
    383381  }
    384382
    385   bool KeyBinder::executeBinding(KeyBinding& binding)
     383  bool KeyBinder::executeSimpleBinding(KeyBinding& binding)
    386384  {
    387385    if (binding.commandStr != "")
    388386    {
    389       //if (binding.commandStr != binding.evaluation.getCommandString())
    390       //{
    391       //  // key binding has changed, reevaluate the command string.
    392       //  binding.evaluation = CommandExecutor::evaluate(binding.commandStr);
    393       //  binding.commandStr = binding.evaluation.getCommandString();
    394       //}
    395       COUT(3) << "Executing command: " << binding.commandStr << std::endl;
     387      if (binding.commandStr != binding.evaluation.getCommandString())
     388      {
     389        // key binding has changed, reevaluate the command string.
     390        binding.evaluation = CommandExecutor::evaluate(binding.commandStr);
     391        binding.commandStr = binding.evaluation.getCommandString();
     392      }
     393      COUT(ORX_DEBUG) << "Keybinding: Executing command: " << binding.commandStr << std::endl;
    396394      CommandExecutor::execute(binding.commandStr);
    397395    }
     
    405403    @param e Event information
    406404  */
    407   bool KeyBinder::keyPressed(const OIS::KeyEvent &e)
    408   {
    409     COUT(3) << "Key: " << e.key << std::endl;
    410     // find the appropriate key binding
    411     executeBinding(bindingsKeyPress_[int(e.key)]);
    412      
     405  bool KeyBinder::keyPressed(const KeyEvent& evt)
     406  {
     407    // find the appropriate key binding
     408    executeSimpleBinding(bindingsKeyPress_[int(evt.key)]);
     409
    413410    return true;
    414411  }
     
    418415    @param e Event information
    419416  */
    420   bool KeyBinder::keyReleased(const OIS::KeyEvent &e)
    421   {
    422     // find the appropriate key binding
    423     executeBinding(bindingsKeyRelease_[int(e.key)]);
     417  bool KeyBinder::keyReleased(const KeyEvent& evt)
     418  {
     419    // find the appropriate key binding
     420    executeSimpleBinding(bindingsKeyRelease_[int(evt.key)]);
    424421
    425422    return true;
     
    428425  /**
    429426    @brief Event handler for the keyHeld Event.
    430     @param e Event information
    431   */
    432   bool KeyBinder::keyHeld(const OIS::KeyEvent &e)
    433   {
    434     // find the appropriate key binding
    435     executeBinding(bindingsKeyHold_[int(e.key)]);
     427    @param e Mouse state information
     428  */
     429  bool KeyBinder::keyHeld(const KeyEvent& evt)
     430  {
     431    // find the appropriate key binding
     432    executeSimpleBinding(bindingsKeyHold_[int(evt.key)]);
    436433
    437434    return true;
     
    440437  /**
    441438    @brief Event handler for the mouseMoved Event.
    442     @param e Event information
    443   */
    444   bool KeyBinder::mouseMoved(const OIS::MouseEvent &e)
     439    @param e Mouse state information
     440  */
     441  bool KeyBinder::mouseMoved(const MouseState &evt)
     442  {
     443    /*if (bindingMouseMoved_.commandStr != "")
     444    {
     445      if (bindingMouseMoved_.commandStr != bindingMouseMoved_.evaluation.getCommandString())
     446      {
     447        // key binding has changed, reevaluate the command string.
     448        bindingMouseMoved_.evaluation = CommandExecutor::evaluate(bindingMouseMoved_.commandStr);
     449        bindingMouseMoved_.commandStr = bindingMouseMoved_.evaluation.getCommandString();
     450      }
     451      COUT(3) << "Executing command: " << bindingMouseMoved_.commandStr << std::endl;
     452
     453      bindingMouseMoved_.evaluation.setEvaluatedParameter(
     454      CommandExecutor::execute(bindingMouseMoved_.commandStr);
     455    }*/
     456
     457    return true;
     458  }
     459
     460  /**
     461    @brief Event handler for the mouseScrolled Event.
     462    @param e Mouse state information
     463  */
     464  bool KeyBinder::mouseScrolled(const MouseState &evt)
    445465  {
    446466    return true;
     
    452472    @param id The ID of the mouse button
    453473  */
    454   bool KeyBinder::mousePressed(const OIS::MouseEvent &e, OIS::MouseButtonID id)
    455   {
    456     // find the appropriate key binding
    457     std::string cmdStr = bindingsMouseButtonPress_[int(id)];
    458     if (cmdStr != "")
    459     {
    460       CommandExecutor::execute(cmdStr);
    461       COUT(3) << "Executing command: " << cmdStr << std::endl;
    462     }
     474  bool KeyBinder::mouseButtonPressed(const MouseState& state, MouseButton::Enum id)
     475  {
     476    // find the appropriate key binding
     477    executeSimpleBinding(bindingsMouseButtonPress_[int(id)]);
    463478
    464479    return true;
     
    470485    @param id The ID of the mouse button
    471486  */
    472   bool KeyBinder::mouseReleased(const OIS::MouseEvent &e, OIS::MouseButtonID id)
    473   {
    474     // find the appropriate key binding
    475     std::string cmdStr = bindingsMouseButtonRelease_[int(id)];
    476     if (cmdStr != "")
    477     {
    478       CommandExecutor::execute(cmdStr);
    479       COUT(3) << "Executing command: " << cmdStr << std::endl;
    480     }
     487  bool KeyBinder::mouseButtonReleased(const MouseState& state, MouseButton::Enum id)
     488  {
     489    // find the appropriate key binding
     490    executeSimpleBinding(bindingsMouseButtonRelease_[int(id)]);
    481491
    482492    return true;
     
    488498    @param id The ID of the mouse button
    489499  */
    490   bool KeyBinder::mouseHeld(const OIS::MouseEvent &e, OIS::MouseButtonID id)
    491   {
    492     // find the appropriate key binding
    493     std::string cmdStr = bindingsMouseButtonHold_[int(id)];
    494     if (cmdStr != "")
    495     {
    496       CommandExecutor::execute(cmdStr);
    497       COUT(3) << "Executing command: " << cmdStr << std::endl;
    498     }
    499 
    500     return true;
    501   }
    502 
    503   bool KeyBinder::buttonPressed(int joyStickID, const OIS::JoyStickEvent &arg, int button)
    504   {
    505     // find the appropriate key binding
    506     std::string cmdStr = bindingsJoyStickButtonPress_[button];
    507     if (cmdStr != "")
    508     {
    509       CommandExecutor::execute(cmdStr);
    510       COUT(3) << "Executing command: " << cmdStr << std::endl;
    511     }
    512 
    513     return true;
    514   }
    515 
    516   bool KeyBinder::buttonReleased(int joyStickID, const OIS::JoyStickEvent &arg, int button)
    517   {
    518     // find the appropriate key binding
    519     std::string cmdStr = bindingsJoyStickButtonRelease_[button];
    520     if (cmdStr != "")
    521     {
    522       CommandExecutor::execute(cmdStr);
    523       COUT(3) << "Executing command: " << cmdStr << std::endl;
    524     }
    525 
    526     return true;
    527   }
    528 
    529   bool KeyBinder::buttonHeld(int joyStickID, const OIS::JoyStickEvent &arg, int button)
    530   {
    531     // find the appropriate key binding
    532     std::string cmdStr = bindingsJoyStickButtonHold_[button];
    533     if (cmdStr != "")
    534     {
    535       CommandExecutor::execute(cmdStr);
    536       COUT(3) << "Executing command: " << cmdStr << std::endl;
    537     }
    538 
    539     return true;
    540   }
    541 
    542   bool KeyBinder::axisMoved(int joyStickID, const OIS::JoyStickEvent &arg, int axis)
    543   {
    544     return true;
    545   }
    546 
    547   bool KeyBinder::sliderMoved(int joyStickID, const OIS::JoyStickEvent &arg, int id)
    548   {
    549     return true;
    550   }
    551 
    552   bool KeyBinder::povMoved(int joyStickID, const OIS::JoyStickEvent &arg, int id)
    553   {
    554     return true;
    555   }
    556 
    557   bool KeyBinder::vector3Moved(int joyStickID, const OIS::JoyStickEvent &arg, int id)
     500  bool KeyBinder::mouseButtonHeld(const MouseState& state, MouseButton::Enum id)
     501  {
     502    // find the appropriate key binding
     503    executeSimpleBinding(bindingsMouseButtonHold_[int(id)]);
     504
     505    return true;
     506  }
     507
     508  bool KeyBinder::joyStickButtonPressed(const JoyStickState& state, int button)
     509  {
     510    // find the appropriate key binding
     511    executeSimpleBinding(bindingsJoyStickButtonPress_[button]);
     512
     513    return true;
     514  }
     515
     516  bool KeyBinder::joyStickButtonReleased(const JoyStickState& state, int button)
     517  {
     518    // find the appropriate key binding
     519    executeSimpleBinding(bindingsJoyStickButtonRelease_[button]);
     520
     521    return true;
     522  }
     523
     524  bool KeyBinder::joyStickButtonHeld(const JoyStickState& state, int button)
     525  {
     526    // find the appropriate key binding
     527    executeSimpleBinding(bindingsJoyStickButtonHold_[button]);
     528
     529    return true;
     530  }
     531
     532  bool KeyBinder::joyStickAxisMoved(const JoyStickState& state, int axis)
     533  {
     534    return true;
     535  }
     536
     537  bool KeyBinder::joyStickSliderMoved(const JoyStickState& state, int index)
     538  {
     539    return true;
     540  }
     541
     542  bool KeyBinder::joyStickPovMoved(const JoyStickState& state, int index)
     543  {
     544    return true;
     545  }
     546
     547  bool KeyBinder::joyStickVector3Moved(const JoyStickState& state, int index)
    558548  {
    559549    return true;
     
    586576  //bool GUIInputHandler::keyPressed(const OIS::KeyEvent &e)
    587577  //{
    588                 ////CEGUI::System::getSingleton().injectKeyDown( arg.key );
    589                 ////CEGUI::System::getSingleton().injectChar( arg.text );
     578    ////CEGUI::System::getSingleton().injectKeyDown( arg.key );
     579    ////CEGUI::System::getSingleton().injectChar( arg.text );
    590580  //  return true;
    591581  //}
     
    597587  //bool GUIInputHandler::keyReleased(const OIS::KeyEvent &e)
    598588  //{
    599                 ////CEGUI::System::getSingleton().injectKeyUp( arg.key );
     589    ////CEGUI::System::getSingleton().injectKeyUp( arg.key );
    600590  //  return true;
    601591  //}
     
    607597  //bool GUIInputHandler::mouseMoved(const OIS::MouseEvent &e)
    608598  //{
    609                 ////CEGUI::System::getSingleton().injectMouseMove( arg.state.X.rel, arg.state.Y.rel );
     599    ////CEGUI::System::getSingleton().injectMouseMove( arg.state.X.rel, arg.state.Y.rel );
    610600  //  return true;
    611601  //}
     
    616606  //  @param id The ID of the mouse button
    617607  //*/
    618   //bool GUIInputHandler::mousePressed(const OIS::MouseEvent &e, OIS::MouseButtonID id)
     608  //bool GUIInputHandler::mousePressed(const OIS::MouseEvent &e, OIS::MouseButton id)
    619609  //{
    620                 ////CEGUI::System::getSingleton().injectMouseButtonDown(convertOISMouseButtonToCegui(id));
     610    ////CEGUI::System::getSingleton().injectMouseButtonDown(convertOISMouseButtonToCegui(id));
    621611  //  return true;
    622612  //}
     
    627617  //  @param id The ID of the mouse button
    628618  //*/
    629   //bool GUIInputHandler::mouseReleased(const OIS::MouseEvent &e, OIS::MouseButtonID id)
     619  //bool GUIInputHandler::mouseReleased(const OIS::MouseEvent &e, OIS::MouseButton id)
    630620  //{
    631                 ////CEGUI::System::getSingleton().injectMouseButtonUp(convertOISMouseButtonToCegui(id));
     621    ////CEGUI::System::getSingleton().injectMouseButtonUp(convertOISMouseButtonToCegui(id));
    632622  //  return true;
    633623  //}
  • code/trunk/src/core/InputHandler.h

    r1219 r1293  
    3838
    3939#include <string>
     40
    4041#include "ois/OIS.h"
    4142#include "OrxonoxClass.h"
    4243#include "CommandExecutor.h"
     44#include "InputInterfaces.h"
    4345
    4446namespace orxonox
     
    5456    };
    5557  }
    56 
    57   /**
    58     @brief Interface class used for key input listeners.
    59   */
    60   class _CoreExport KeyHandler : public OIS::KeyListener
    61   {
    62   public:
    63     virtual ~KeyHandler() { }
    64     virtual bool keyHeld(const OIS::KeyEvent &arg) = 0;
    65   };
    66 
    67   /**
    68     @brief Interface class used for mouse input listeners.
    69   */
    70   class _CoreExport MouseHandler : public OIS::MouseListener
    71   {
    72   public:
    73     virtual ~MouseHandler() { }
    74     virtual bool mouseHeld(const OIS::MouseEvent &arg, OIS::MouseButtonID id) = 0;
    75   };
    76 
    77   /**
    78     @brief Interface class used for joy stick input listeners.
    79   */
    80   class _CoreExport JoyStickHandler
    81   {
    82   public:
    83     virtual ~JoyStickHandler() { }
    84                 virtual bool buttonPressed (int joyStickID, const OIS::JoyStickEvent &arg, int button) = 0;
    85                 virtual bool buttonReleased(int joyStickID, const OIS::JoyStickEvent &arg, int button) = 0;
    86     virtual bool buttonHeld    (int joyStickID, const OIS::JoyStickEvent &arg, int button) = 0;
    87                 virtual bool axisMoved     (int joyStickID, const OIS::JoyStickEvent &arg, int axis)   = 0;
    88                 virtual bool sliderMoved   (int joyStickID, const OIS::JoyStickEvent &arg, int index) {return true;}
    89                 virtual bool povMoved      (int joyStickID, const OIS::JoyStickEvent &arg, int index) {return true;}
    90                 virtual bool vector3Moved  (int joyStickID, const OIS::JoyStickEvent &arg, int index) {return true;}
    91   };
    9258
    9359  struct _CoreExport KeyBinding
     
    11379    void setConfigValues();
    11480
    115     std::string testtest;
    116 
    11781  private: // functions
    11882
    119     bool executeBinding(KeyBinding &binding);
     83    bool executeSimpleBinding(KeyBinding &binding);
    12084
    121                 bool keyPressed   (const OIS::KeyEvent   &arg);
    122                 bool keyReleased  (const OIS::KeyEvent   &arg);
    123                 bool keyHeld      (const OIS::KeyEvent   &arg);
     85    bool keyPressed (const KeyEvent& evt);
     86    bool keyReleased(const KeyEvent& evt);
     87    bool keyHeld    (const KeyEvent& evt);
    12488
    125     bool mousePressed (const OIS::MouseEvent &arg, OIS::MouseButtonID id);
    126                 bool mouseReleased(const OIS::MouseEvent &arg, OIS::MouseButtonID id);
    127                 bool mouseHeld    (const OIS::MouseEvent &arg, OIS::MouseButtonID id);
    128     bool mouseMoved   (const OIS::MouseEvent &arg);
     89    bool mouseButtonPressed (const MouseState& state, MouseButton::Enum id);
     90    bool mouseButtonReleased(const MouseState& state, MouseButton::Enum id);
     91    bool mouseButtonHeld    (const MouseState& state, MouseButton::Enum id);
     92    bool mouseMoved         (const MouseState& state);
     93    bool mouseScrolled      (const MouseState& state);
    12994
    130                 bool buttonPressed (int joyStickID, const OIS::JoyStickEvent &arg, int button);
    131                 bool buttonReleased(int joyStickID, const OIS::JoyStickEvent &arg, int button);
    132                 bool buttonHeld    (int joyStickID, const OIS::JoyStickEvent &arg, int button);
    133                 bool axisMoved     (int joyStickID, const OIS::JoyStickEvent &arg, int axis);
    134                 bool sliderMoved   (int joyStickID, const OIS::JoyStickEvent &arg, int id);
    135                 bool povMoved      (int joyStickID, const OIS::JoyStickEvent &arg, int id);
    136                 bool vector3Moved  (int joyStickID, const OIS::JoyStickEvent &arg, int id);
     95    bool joyStickButtonPressed (const JoyStickState& state, int button);
     96    bool joyStickButtonReleased(const JoyStickState& state, int button);
     97    bool joyStickButtonHeld    (const JoyStickState& state, int button);
     98    bool joyStickAxisMoved     (const JoyStickState& state, int axis)  ;
     99    bool joyStickSliderMoved   (const JoyStickState& state, int index) ;
     100    bool joyStickPovMoved      (const JoyStickState& state, int index) ;
     101    bool joyStickVector3Moved  (const JoyStickState& state, int index) ;
    137102
    138103  private: // variables
     
    152117    static const int numberOfMouseButtons_s = 8;
    153118    //! Array of input events for every pressed mouse button
    154     std::string bindingsMouseButtonPress_  [numberOfMouseButtons_s];
     119    KeyBinding bindingsMouseButtonPress_  [numberOfMouseButtons_s];
    155120    //! Array of input events for every released mouse button
    156     std::string bindingsMouseButtonRelease_[numberOfMouseButtons_s];
     121    KeyBinding bindingsMouseButtonRelease_[numberOfMouseButtons_s];
    157122    //! Array of input events for every held mouse button
    158     std::string bindingsMouseButtonHold_   [numberOfMouseButtons_s];
     123    KeyBinding bindingsMouseButtonHold_   [numberOfMouseButtons_s];
     124    //! Key binding for mouse moved event
     125    KeyBinding bindingMouseMoved_;
     126    //! Key binding for mouse scrolled event
     127    KeyBinding bindingMouseScrolled_;
    159128    //! Names of the mouse buttons as strings
    160129    std::string mouseButtonNames_[numberOfMouseButtons_s];
     
    163132    static const int numberOfJoyStickButtons_s = 32;
    164133    //! Array of input events for every pressed joy stick button
    165     std::string bindingsJoyStickButtonPress_  [numberOfJoyStickButtons_s];
     134    KeyBinding bindingsJoyStickButtonPress_  [numberOfJoyStickButtons_s];
    166135    //! Array of input events for every released joy stick button
    167     std::string bindingsJoyStickButtonRelease_[numberOfJoyStickButtons_s];
     136    KeyBinding bindingsJoyStickButtonRelease_[numberOfJoyStickButtons_s];
    168137    //! Array of input events for every held joy stick button
    169     std::string bindingsJoyStickButtonHold_   [numberOfJoyStickButtons_s];
     138    KeyBinding bindingsJoyStickButtonHold_   [numberOfJoyStickButtons_s];
    170139    //! Names of the joy stick buttons as strings
    171140    std::string joyStickButtonNames_[numberOfJoyStickButtons_s];
     
    186155  //private:
    187156  //  // input events
    188                 //bool keyPressed   (const OIS::KeyEvent   &arg);
    189                 //bool keyReleased  (const OIS::KeyEvent   &arg);
    190                 //bool keyHeld      (const OIS::KeyEvent   &arg);
     157    //bool keyPressed   (const OIS::KeyEvent   &arg);
     158    //bool keyReleased  (const OIS::KeyEvent   &arg);
     159    //bool keyHeld      (const OIS::KeyEvent   &arg);
    191160
    192   //  bool mousePressed (const OIS::MouseEvent &arg, OIS::MouseButtonID id);
    193                 //bool mouseReleased(const OIS::MouseEvent &arg, OIS::MouseButtonID id);
    194                 //bool mouseHeld    (const OIS::MouseEvent &arg, OIS::MouseButtonID id);
     161  //  bool mousePressed (const OIS::MouseEvent &arg, OIS::MouseButton id);
     162    //bool mouseReleased(const OIS::MouseEvent &arg, OIS::MouseButton id);
     163    //bool mouseHeld    (const OIS::MouseEvent &arg, OIS::MouseButton id);
    195164  //  bool mouseMoved   (const OIS::MouseEvent &arg);
    196165
    197                 //bool buttonPressed (const OIS::JoyStickEvent &arg, int button);
    198                 //bool buttonReleased(const OIS::JoyStickEvent &arg, int button);
    199                 //bool buttonHeld    (const OIS::JoyStickEvent &arg, int button);
    200                 //bool axisMoved     (const OIS::JoyStickEvent &arg, int axis);
    201                 //bool sliderMoved   (const OIS::JoyStickEvent &arg, int id);
    202                 //bool povMoved      (const OIS::JoyStickEvent &arg, int id);
     166    //bool buttonPressed (const OIS::JoyStickEvent &arg, int button);
     167    //bool buttonReleased(const OIS::JoyStickEvent &arg, int button);
     168    //bool buttonHeld    (const OIS::JoyStickEvent &arg, int button);
     169    //bool axisMoved     (const OIS::JoyStickEvent &arg, int axis);
     170    //bool sliderMoved   (const OIS::JoyStickEvent &arg, int id);
     171    //bool povMoved      (const OIS::JoyStickEvent &arg, int id);
    203172  //};
    204173
  • code/trunk/src/core/InputManager.cc

    r1219 r1293  
    3030  @file
    3131  @brief Implementation of the InputManager that captures all the input from OIS
    32          and redirects it to handlers if necessary.
     32         and redirects it to handlers.
    3333 */
    3434
     
    5252  InputManager::InputManager() :
    5353      inputSystem_(0), keyboard_(0), mouse_(0),
    54       state_(IS_UNINIT), stateRequest_(IS_UNINIT)
     54      joySticksSize_(0),
     55      state_(IS_UNINIT), stateRequest_(IS_UNINIT),
     56      keyboardModifiers_(0)
    5557  {
    5658    RegisterObject(InputManager);
    57 
    58     this->joySticks_.reserve(5);
    59     //this->activeJoyStickHandlers_.reserve(10);
    60     this->activeKeyHandlers_.reserve(10);
    61     this->activeMouseHandlers_.reserve(10);
    6259  }
    6360
     
    8784    @param windowHeight The height of the render window
    8885  */
    89   bool InputManager::_initialise(const size_t windowHnd, const int windowWidth, const int windowHeight,
    90         const bool createKeyboard, const bool createMouse, const bool createJoySticks)
     86  bool InputManager::_initialise(const size_t windowHnd, int windowWidth, int windowHeight,
     87        bool createKeyboard, bool createMouse, bool createJoySticks)
    9188  {
    9289    if (state_ == IS_UNINIT)
    9390    {
     91      CCOUT(3) << "Initialising Input System..." << std::endl;
    9492      CCOUT(ORX_DEBUG) << "Initialising OIS components..." << std::endl;
    9593
     
    145143    addKeyHandler(binder, "keybinder");
    146144    addMouseHandler(binder, "keybinder");
     145    addJoyStickHandler(binder, "keybinder");
    147146
    148147    // Read all the key bindings and assign them
     
    234233  bool InputManager::_initialiseJoySticks()
    235234  {
    236     if (joySticks_.size() > 0)
     235    if (joySticksSize_ > 0)
    237236    {
    238237      CCOUT(2) << "Warning: Joy sticks already initialised, skipping." << std::endl;
     
    265264      return false;
    266265    }
     266    joySticksSize_ = joySticks_.size();
     267    activeJoyStickHandlers_.resize(joySticksSize_);
     268    joyStickButtonsDown_.resize(joySticksSize_);
    267269    return success;
    268270  }
     
    273275  void InputManager::_destroy()
    274276  {
    275     CCOUT(ORX_DEBUG) << "Destroying ..." << std::endl;
    276 
    277277    if (state_ != IS_UNINIT)
    278278    {
     279      CCOUT(ORX_DEBUG) << "Destroying ..." << std::endl;
     280
    279281      if (keyHandlers_.find("buffer") != keyHandlers_.end())
    280282        delete keyHandlers_["buffer"];
     
    296298
    297299      state_ = IS_UNINIT;
    298     }
    299     else
    300       CCOUT(ORX_WARNING) << "Warning: Cannot be destroyed, since not initialised." << std::endl;
    301 
    302     CCOUT(ORX_DEBUG) << "Destroying done." << std::endl;
     300      CCOUT(ORX_DEBUG) << "Destroying done." << std::endl;
     301    }
    303302  }
    304303
     
    336335  void InputManager::_destroyJoySticks()
    337336  {
    338     if (joySticks_.size() > 0)
     337    if (joySticksSize_ > 0)
    339338    {
    340339      // note: inputSystem_ can never be 0, or else the code is mistaken
    341       for (unsigned int i = 0; i < joySticks_.size(); i++)
     340      for (unsigned int i = 0; i < joySticksSize_; i++)
    342341        if (joySticks_[i] != 0)
    343342          inputSystem_->destroyInputObject(joySticks_[i]);
    344343
    345344      joySticks_.clear();
     345      joySticksSize_ = 0;
    346346      activeJoyStickHandlers_.clear();
    347347      joyStickButtonsDown_.clear();
     
    372372        activeKeyHandlers_.clear();
    373373        activeMouseHandlers_.clear();
    374         activeJoyStickHandlers_.clear();
     374        for (unsigned int i = 0; i < joySticksSize_; i++)
     375          activeJoyStickHandlers_[i].clear();
    375376
    376377        switch (stateRequest_)
     
    381382          activeKeyHandlers_.push_back(keyHandlers_["keybinder"]);
    382383          activeMouseHandlers_.push_back(mouseHandlers_["keybinder"]);
    383           activeMouseHandlers_.push_back(mouseHandlers_["SpaceShip"]);
    384           for (std::vector<OIS::JoyStick*>::const_iterator it = joySticks_.begin();
    385                 it != joySticks_.end(); it++)
    386             activeJoyStickHandlers_[*it].push_back(joyStickHandlers_["keybinder"]);
     384          if (getMouseHandler("SpaceShip"))
     385            activeMouseHandlers_.push_back(mouseHandlers_["SpaceShip"]);
     386          for (unsigned int i = 0; i < joySticksSize_; i++)
     387            activeJoyStickHandlers_[i].push_back(joyStickHandlers_["keybinder"]);
    387388          break;
    388389
     
    393394        case IS_CONSOLE:
    394395          activeMouseHandlers_.push_back(mouseHandlers_["keybinder"]);
    395           for (std::vector<OIS::JoyStick*>::const_iterator it = joySticks_.begin();
    396                 it != joySticks_.end(); it++)
    397             activeJoyStickHandlers_[*it].push_back(joyStickHandlers_["keybinder"]);
     396          if (getMouseHandler("SpaceShip"))
     397            activeMouseHandlers_.push_back(mouseHandlers_["SpaceShip"]);
     398          for (unsigned int i = 0; i < joySticksSize_; i++)
     399            activeJoyStickHandlers_[i].push_back(joyStickHandlers_["keybinder"]);
    398400
    399401          activeKeyHandlers_.push_back(keyHandlers_["buffer"]);
     
    412414    if (keyboard_)
    413415      keyboard_->capture();
     416    for (unsigned  int i = 0; i < joySticksSize_; i++)
     417      joySticks_[i]->capture();
    414418
    415419
    416420    // call all the handlers for the held key events
    417     for (std::list<OIS::KeyCode>::const_iterator itKey = keysDown_.begin();
    418           itKey != keysDown_.end(); itKey++)
    419     {
    420       OIS::KeyEvent keyArg(keyboard_, *itKey, 0);
    421       for (unsigned int i = 0; i < activeKeyHandlers_.size(); i++)
    422         activeKeyHandlers_[i]->keyHeld(keyArg);
    423     }
     421    for (unsigned int iKey = 0; iKey < keysDown_.size(); iKey++)
     422      for (unsigned int iHandler = 0; iHandler < activeKeyHandlers_.size(); iHandler++)
     423        activeKeyHandlers_[iHandler]->keyHeld(KeyEvent(keysDown_[iKey], keyboardModifiers_));
    424424
    425425    // call all the handlers for the held mouse button events
    426     for (std::list<OIS::MouseButtonID>::const_iterator itMouseButton = mouseButtonsDown_.begin();
    427           itMouseButton != mouseButtonsDown_.end(); itMouseButton++)
    428     {
    429       OIS::MouseEvent mouseButtonArg(mouse_, mouse_->getMouseState());
    430       for (unsigned int i = 0; i < activeMouseHandlers_.size(); i++)
    431         activeMouseHandlers_[i]->mouseHeld(mouseButtonArg, *itMouseButton);
    432     }
     426    for (unsigned int iButton = 0; iButton < mouseButtonsDown_.size(); iButton++)
     427      for (unsigned int iHandler = 0; iHandler < activeMouseHandlers_.size(); iHandler++)
     428        activeMouseHandlers_[iHandler]->mouseButtonHeld(mouse_->getMouseState(), mouseButtonsDown_[iButton]);
    433429
    434430    // call all the handlers for the held joy stick button events
    435     for (std::map< OIS::JoyStick*, std::list <int> >::const_iterator itJoyStick = joyStickButtonsDown_.begin();
    436           itJoyStick != joyStickButtonsDown_.end(); itJoyStick++)
    437     {
    438       OIS::JoyStick* joyStick = (*itJoyStick).first;
    439       for (std::list<int>::const_iterator itJoyStickButton = (*itJoyStick).second.begin();
    440             itJoyStickButton != (*itJoyStick).second.end(); itJoyStickButton++)
    441       {
    442         OIS::JoyStickEvent joyStickButtonArg(joyStick, joyStick->getJoyStickState());
    443         for (unsigned int i = 0; i < activeJoyStickHandlers_[joyStick].size(); i++)
    444           activeJoyStickHandlers_[joyStick][i]->buttonHeld(i, joyStickButtonArg, *itJoyStickButton);
    445       }
    446     }
    447   }
    448 
     431    for (unsigned int iJoyStick  = 0; iJoyStick < joySticksSize_; iJoyStick++)
     432      for (unsigned int iButton   = 0; iButton   < joyStickButtonsDown_[iJoyStick].size(); iButton++)
     433        for (unsigned int iHandler = 0; iHandler  < activeJoyStickHandlers_[iJoyStick].size(); iHandler++)
     434          activeJoyStickHandlers_[iJoyStick][iHandler]->joyStickButtonHeld(
     435              JoyStickState(joySticks_[iJoyStick]->getJoyStickState(), iJoyStick), joyStickButtonsDown_[iJoyStick][iButton]);
     436  }
    449437
    450438  // ###### Key Events ######
     
    457445  {
    458446    // check whether the key already is in the list (can happen when focus was lost)
    459     for (std::list<OIS::KeyCode>::iterator it = keysDown_.begin(); it != keysDown_.end(); it++)
    460     {
    461       if (*it == e.key)
    462       {
    463         keysDown_.erase(it);
    464         break;
    465       }
    466     }
    467     keysDown_.push_back(e.key);
     447    unsigned int iKey = 0;
     448    while (iKey < keysDown_.size() && keysDown_[iKey].key != (KeyCode::Enum)e.key)
     449      iKey++;
     450    if (iKey == keysDown_.size())
     451      keysDown_.push_back(Key(e));
     452
     453    // update modifiers
     454    if(e.key == OIS::KC_RMENU    || e.key == OIS::KC_LMENU)
     455      keyboardModifiers_ |= KeyboardModifier::Alt;   // alt key
     456    if(e.key == OIS::KC_RCONTROL || e.key == OIS::KC_LCONTROL)
     457      keyboardModifiers_ |= KeyboardModifier::Ctrl;  // ctrl key
     458    if(e.key == OIS::KC_RSHIFT   || e.key == OIS::KC_LSHIFT)
     459      keyboardModifiers_ |= KeyboardModifier::Shift; // shift key
    468460
    469461    for (unsigned int i = 0; i < activeKeyHandlers_.size(); i++)
    470       activeKeyHandlers_[i]->keyPressed(e);
     462      activeKeyHandlers_[i]->keyPressed(KeyEvent(e, keyboardModifiers_));
    471463
    472464    return true;
     
    480472  {
    481473    // remove the key from the keysDown_ list
    482     for (std::list<OIS::KeyCode>::iterator it = keysDown_.begin(); it != keysDown_.end(); it++)
    483     {
    484       if (*it == e.key)
    485       {
    486         keysDown_.erase(it);
     474    for (unsigned int iKey = 0; iKey < keysDown_.size(); iKey++)
     475    {
     476      if (keysDown_[iKey].key == (KeyCode::Enum)e.key)
     477      {
     478        keysDown_.erase(keysDown_.begin() + iKey);
    487479        break;
    488480      }
    489481    }
    490482
     483    // update modifiers
     484    if(e.key == OIS::KC_RMENU    || e.key == OIS::KC_LMENU)
     485      keyboardModifiers_ &= ~KeyboardModifier::Alt;   // alt key
     486    if(e.key == OIS::KC_RCONTROL || e.key == OIS::KC_LCONTROL)
     487      keyboardModifiers_ &= ~KeyboardModifier::Ctrl;  // ctrl key
     488    if(e.key == OIS::KC_RSHIFT   || e.key == OIS::KC_LSHIFT)
     489      keyboardModifiers_ &= ~KeyboardModifier::Shift; // shift key
     490
    491491    for (unsigned int i = 0; i < activeKeyHandlers_.size(); i++)
    492       activeKeyHandlers_[i]->keyReleased(e);
     492      activeKeyHandlers_[i]->keyReleased(KeyEvent(e, keyboardModifiers_));
    493493
    494494    return true;
     
    504504  bool InputManager::mouseMoved(const OIS::MouseEvent &e)
    505505  {
    506     for (unsigned int i = 0; i < activeMouseHandlers_.size(); i++)
    507       activeMouseHandlers_[i]->mouseMoved(e);
     506    // check for actual moved event
     507    if (e.state.X.rel != 0 || e.state.Y.rel != 0)
     508    {
     509      for (unsigned int i = 0; i < activeMouseHandlers_.size(); i++)
     510        activeMouseHandlers_[i]->mouseMoved(e.state);
     511    }
     512
     513    // check for mouse scrolled event
     514    if (e.state.Z.rel != 0)
     515    {
     516      for (unsigned int i = 0; i < activeMouseHandlers_.size(); i++)
     517        activeMouseHandlers_[i]->mouseScrolled(e.state);
     518    }
    508519
    509520    return true;
     
    518529  {
    519530    // check whether the button already is in the list (can happen when focus was lost)
    520     for (std::list<OIS::MouseButtonID>::iterator it = mouseButtonsDown_.begin(); it != mouseButtonsDown_.end(); it++)
    521     {
    522       if (*it == id)
    523       {
    524         mouseButtonsDown_.erase(it);
    525         break;
    526       }
    527     }
    528     mouseButtonsDown_.push_back(id);
     531    unsigned int iButton = 0;
     532    while (iButton < mouseButtonsDown_.size() && mouseButtonsDown_[iButton] != (MouseButton::Enum)id)
     533      iButton++;
     534    if (iButton == mouseButtonsDown_.size())
     535      mouseButtonsDown_.push_back((MouseButton::Enum)id);
    529536
    530537    for (unsigned int i = 0; i < activeMouseHandlers_.size(); i++)
    531       activeMouseHandlers_[i]->mousePressed(e, id);
     538      activeMouseHandlers_[i]->mouseButtonPressed(e.state, (MouseButton::Enum)id);
    532539
    533540    return true;
     
    542549  {
    543550    // remove the button from the keysDown_ list
    544     for (std::list<OIS::MouseButtonID>::iterator it = mouseButtonsDown_.begin(); it != mouseButtonsDown_.end(); it++)
    545     {
    546       if (*it == id)
    547       {
    548         mouseButtonsDown_.erase(it);
     551    for (unsigned int iButton = 0; iButton < mouseButtonsDown_.size(); iButton++)
     552    {
     553      if (mouseButtonsDown_[iButton] == (MouseButton::Enum)id)
     554      {
     555        mouseButtonsDown_.erase(mouseButtonsDown_.begin() + iButton);
    549556        break;
    550557      }
     
    552559
    553560    for (unsigned int i = 0; i < activeMouseHandlers_.size(); i++)
    554       activeMouseHandlers_[i]->mouseReleased(e, id);
     561      activeMouseHandlers_[i]->mouseButtonReleased(e.state, (MouseButton::Enum)id);
    555562
    556563    return true;
     
    562569  bool InputManager::buttonPressed(const OIS::JoyStickEvent &arg, int button)
    563570  {
     571    // use the device to identify which one called the method
    564572    OIS::JoyStick* joyStick = (OIS::JoyStick*)arg.device;
     573    unsigned int iJoyStick = 0;
     574    while (joySticks_[iJoyStick] != joyStick)
     575      iJoyStick++;
    565576
    566577    // check whether the button already is in the list (can happen when focus was lost)
    567     std::list<int>& buttonsDownList = joyStickButtonsDown_[joyStick];
    568     for (std::list<int>::iterator it = buttonsDownList.begin(); it != buttonsDownList.end(); it++)
    569     {
    570       if (*it == button)
    571       {
    572         buttonsDownList.erase(it);
     578    std::vector<int> buttonsDown = joyStickButtonsDown_[iJoyStick];
     579    unsigned int iButton = 0;
     580    while (iButton < buttonsDown.size() && buttonsDown[iButton] != button)
     581      iButton++;
     582    if (iButton == buttonsDown.size())
     583      buttonsDown.push_back(button);
     584
     585    for (unsigned int iHandler = 0; iHandler < activeJoyStickHandlers_[iJoyStick].size(); iHandler++)
     586      activeJoyStickHandlers_[iJoyStick][iHandler]->joyStickButtonPressed(JoyStickState(arg.state, iJoyStick), button);
     587
     588    return true;
     589  }
     590
     591  bool InputManager::buttonReleased(const OIS::JoyStickEvent &arg, int button)
     592  {
     593    // use the device to identify which one called the method
     594    OIS::JoyStick* joyStick = (OIS::JoyStick*)arg.device;
     595    unsigned int iJoyStick = 0;
     596    while (joySticks_[iJoyStick] != joyStick)
     597      iJoyStick++;
     598
     599    // remove the button from the joyStickButtonsDown_ list
     600    std::vector<int> buttonsDown = joyStickButtonsDown_[iJoyStick];
     601    for (unsigned int iButton = 0; iButton < buttonsDown.size(); iButton++)
     602    {
     603      if (buttonsDown[iButton] == button)
     604      {
     605        buttonsDown.erase(buttonsDown.begin() + iButton);
    573606        break;
    574607      }
    575608    }
    576     joyStickButtonsDown_[joyStick].push_back(button);
    577 
    578     for (unsigned int i = 0; i < activeJoyStickHandlers_[joyStick].size(); i++)
    579       activeJoyStickHandlers_[joyStick][i]->buttonPressed(i, arg, button);
    580 
    581     return true;
    582   }
    583 
    584   bool InputManager::buttonReleased(const OIS::JoyStickEvent &arg, int button)
    585   {
     609
     610    for (unsigned int iHandler = 0; iHandler < activeJoyStickHandlers_[iJoyStick].size(); iHandler++)
     611      activeJoyStickHandlers_[iJoyStick][iHandler]->joyStickButtonReleased(JoyStickState(arg.state, iJoyStick), button);
     612
     613    return true;
     614  }
     615
     616  bool InputManager::axisMoved(const OIS::JoyStickEvent &arg, int axis)
     617  {
     618    // use the device to identify which one called the method
    586619    OIS::JoyStick* joyStick = (OIS::JoyStick*)arg.device;
    587 
    588     // remove the button from the joyStickButtonsDown_ list
    589     std::list<int>& buttonsDownList = joyStickButtonsDown_[joyStick];
    590     for (std::list<int>::iterator it = buttonsDownList.begin(); it != buttonsDownList.end(); it++)
    591     {
    592       if (*it == button)
    593       {
    594         buttonsDownList.erase(it);
    595         break;
    596       }
    597     }
    598 
    599     for (unsigned int i = 0; i < activeJoyStickHandlers_[joyStick].size(); i++)
    600       activeJoyStickHandlers_[joyStick][i]->buttonReleased(i, arg, button);
    601 
    602     return true;
    603   }
    604 
    605   bool InputManager::axisMoved(const OIS::JoyStickEvent &arg, int axis)
    606   {
     620    unsigned int iJoyStick = 0;
     621    while (joySticks_[iJoyStick] != joyStick)
     622      iJoyStick++;
     623
     624    for (unsigned int iHandler = 0; iHandler < activeJoyStickHandlers_[iJoyStick].size(); iHandler++)
     625      activeJoyStickHandlers_[iJoyStick][iHandler]->joyStickAxisMoved(JoyStickState(arg.state, iJoyStick), axis);
     626
     627    return true;
     628  }
     629
     630  bool InputManager::sliderMoved(const OIS::JoyStickEvent &arg, int id)
     631  {
     632    // use the device to identify which one called the method
    607633    OIS::JoyStick* joyStick = (OIS::JoyStick*)arg.device;
    608     for (unsigned int i = 0; i < activeJoyStickHandlers_[joyStick].size(); i++)
    609       activeJoyStickHandlers_[joyStick][i]->axisMoved(i, arg, axis);
    610 
    611     return true;
    612   }
    613 
    614   bool InputManager::sliderMoved(const OIS::JoyStickEvent &arg, int id)
    615   {
     634    unsigned int iJoyStick = 0;
     635    while (joySticks_[iJoyStick] != joyStick)
     636      iJoyStick++;
     637
     638    for (unsigned int iHandler = 0; iHandler < activeJoyStickHandlers_[iJoyStick].size(); iHandler++)
     639      activeJoyStickHandlers_[iJoyStick][iHandler]->joyStickSliderMoved(JoyStickState(arg.state, iJoyStick), id);
     640
     641    return true;
     642  }
     643
     644  bool InputManager::povMoved(const OIS::JoyStickEvent &arg, int id)
     645  {
     646    // use the device to identify which one called the method
    616647    OIS::JoyStick* joyStick = (OIS::JoyStick*)arg.device;
    617     for (unsigned int i = 0; i < activeJoyStickHandlers_[joyStick].size(); i++)
    618       activeJoyStickHandlers_[joyStick][i]->sliderMoved(i, arg, id);
    619 
    620     return true;
    621   }
    622 
    623   bool InputManager::povMoved(const OIS::JoyStickEvent &arg, int id)
    624   {
     648    unsigned int iJoyStick = 0;
     649    while (joySticks_[iJoyStick] != joyStick)
     650      iJoyStick++;
     651
     652    for (unsigned int iHandler = 0; iHandler < activeJoyStickHandlers_[iJoyStick].size(); iHandler++)
     653      activeJoyStickHandlers_[iJoyStick][iHandler]->joyStickPovMoved(JoyStickState(arg.state, iJoyStick), id);
     654
     655    return true;
     656  }
     657
     658  bool InputManager::vector3Moved(const OIS::JoyStickEvent &arg, int id)
     659  {
     660    // use the device to identify which one called the method
    625661    OIS::JoyStick* joyStick = (OIS::JoyStick*)arg.device;
    626     for (unsigned int i = 0; i < activeJoyStickHandlers_[joyStick].size(); i++)
    627       activeJoyStickHandlers_[joyStick][i]->povMoved(i, arg, id);
    628 
    629     return true;
    630   }
    631 
    632   bool InputManager::vector3Moved(const OIS::JoyStickEvent &arg, int id)
    633   {
    634     OIS::JoyStick* joyStick = (OIS::JoyStick*)arg.device;
    635     for (unsigned int i = 0; i < activeJoyStickHandlers_[joyStick].size(); i++)
    636       activeJoyStickHandlers_[joyStick][i]->vector3Moved(i, arg, id);
     662    unsigned int iJoyStick = 0;
     663    while (joySticks_[iJoyStick] != joyStick)
     664      iJoyStick++;
     665
     666    for (unsigned int iHandler = 0; iHandler < activeJoyStickHandlers_[iJoyStick].size(); iHandler++)
     667      activeJoyStickHandlers_[iJoyStick][iHandler]->joyStickVector3Moved(JoyStickState(arg.state, iJoyStick), id);
    637668
    638669    return true;
     
    645676  // ################################
    646677
    647   bool InputManager::initialise(const size_t windowHnd, const int windowWidth, const int windowHeight,
    648     const bool createKeyboard, const bool createMouse, const bool createJoySticks)
     678  bool InputManager::initialise(const size_t windowHnd, int windowWidth, int windowHeight,
     679    bool createKeyboard, bool createMouse, bool createJoySticks)
    649680  {
    650681    return _getSingleton()._initialise(windowHnd, windowWidth, windowHeight,
     
    685716  int InputManager::numberOfJoySticks()
    686717  {
    687     return _getSingleton().joySticks_.size();
     718    return _getSingleton().joySticksSize_;
     719  }
     720
     721  bool InputManager::isKeyDown(KeyCode::Enum key)
     722  {
     723    if (_getSingleton().keyboard_)
     724      return _getSingleton().keyboard_->isKeyDown((OIS::KeyCode)key);
     725    else
     726      return false;
     727  }
     728
     729  bool InputManager::isModifierDown(KeyboardModifier::Enum modifier)
     730  {
     731    if (_getSingleton().keyboard_)
     732      return isModifierDown(modifier);
     733    else
     734      return false;
     735  }
     736
     737  const MouseState InputManager::getMouseState()
     738  {
     739    if (_getSingleton().mouse_)
     740      return _getSingleton().mouse_->getMouseState();
     741    else
     742      return MouseState();
     743  }
     744
     745  const JoyStickState InputManager::getJoyStickState(unsigned int ID)
     746  {
     747    if (ID < _getSingleton().joySticksSize_)
     748      return JoyStickState(_getSingleton().joySticks_[ID]->getJoyStickState(), ID);
     749    else
     750      return JoyStickState();
    688751  }
    689752
     
    757820  bool InputManager::addKeyHandler(KeyHandler* handler, const std::string& name)
    758821  {
     822    if (!handler)
     823      return false;
    759824    if (_getSingleton().keyHandlers_.find(name) == _getSingleton().keyHandlers_.end())
    760825    {
     
    883948  bool InputManager::addMouseHandler(MouseHandler* handler, const std::string& name)
    884949  {
     950    if (!handler)
     951      return false;
    885952    if (_getSingleton().mouseHandlers_.find(name) == _getSingleton().mouseHandlers_.end())
    886953    {
     
    10101077  bool InputManager::addJoyStickHandler(JoyStickHandler* handler, const std::string& name)
    10111078  {
     1079    if (!handler)
     1080      return false;
    10121081    if (_getSingleton().joyStickHandlers_.find(name) == _getSingleton().joyStickHandlers_.end())
    10131082    {
     
    10611130    @return False if name or id was not found, true otherwise.
    10621131  */
    1063   bool InputManager::enableJoyStickHandler(const std::string& name, const int ID)
     1132  bool InputManager::enableJoyStickHandler(const std::string& name, unsigned int ID)
    10641133  {
    10651134    // get handler pointer from the map with all stored handlers
     
    10691138
    10701139    // check for existence of the ID
    1071     if ((unsigned int)ID >= _getSingleton().joySticks_.size())
    1072       return false;
    1073     OIS::JoyStick* joyStick = _getSingleton().joySticks_[ID];
     1140    if (ID >= _getSingleton().joySticksSize_)
     1141      return false;
    10741142
    10751143    // see whether the handler already is in the list
    1076     for (std::vector<JoyStickHandler*>::iterator it = _getSingleton().activeJoyStickHandlers_[joyStick].begin();
    1077           it != _getSingleton().activeJoyStickHandlers_[joyStick].end(); it++)
     1144    for (std::vector<JoyStickHandler*>::iterator it = _getSingleton().activeJoyStickHandlers_[ID].begin();
     1145          it != _getSingleton().activeJoyStickHandlers_[ID].end(); it++)
    10781146    {
    10791147      if ((*it) == (*handlerIt).second)
     
    10831151      }
    10841152    }
    1085     _getSingleton().activeJoyStickHandlers_[joyStick].push_back((*handlerIt).second);
     1153    _getSingleton().activeJoyStickHandlers_[ID].push_back((*handlerIt).second);
    10861154    _getSingleton().stateRequest_ = IS_CUSTOM;
    10871155    return true;
     
    10931161    @return False if name or id was not found, true otherwise.
    10941162  */
    1095   bool InputManager::disableJoyStickHandler(const std::string &name, int ID)
     1163  bool InputManager::disableJoyStickHandler(const std::string &name, unsigned int ID)
    10961164  {
    10971165    // get handler pointer from the map with all stored handlers
     
    11011169
    11021170    // check for existence of the ID
    1103     if ((unsigned int)ID >= _getSingleton().joySticks_.size())
    1104       return false;
    1105     OIS::JoyStick* joyStick = _getSingleton().joySticks_[ID];
     1171    if (ID >= _getSingleton().joySticksSize_)
     1172      return false;
    11061173
    11071174    // look for the handler in the list
    1108     for (std::vector<JoyStickHandler*>::iterator it = _getSingleton().activeJoyStickHandlers_[joyStick].begin();
    1109           it != _getSingleton().activeJoyStickHandlers_[joyStick].end(); it++)
     1175    for (std::vector<JoyStickHandler*>::iterator it = _getSingleton().activeJoyStickHandlers_[ID].begin();
     1176          it != _getSingleton().activeJoyStickHandlers_[ID].end(); it++)
    11101177    {
    11111178      if ((*it) == (*handlerIt).second)
    11121179      {
    1113         _getSingleton().activeJoyStickHandlers_[joyStick].erase(it);
     1180        _getSingleton().activeJoyStickHandlers_[ID].erase(it);
    11141181        _getSingleton().stateRequest_ = IS_CUSTOM;
    11151182        return true;
     
    11241191    @return False if key handler is not active or doesn't exist, true otherwise.
    11251192  */
    1126   bool InputManager::isJoyStickHandlerActive(const std::string& name, const int ID)
     1193  bool InputManager::isJoyStickHandlerActive(const std::string& name, unsigned int ID)
    11271194  {
    11281195    // get handler pointer from the map with all stored handlers
     
    11321199
    11331200    // check for existence of the ID
    1134     if ((unsigned int)ID >= _getSingleton().joySticks_.size())
    1135       return false;
    1136     OIS::JoyStick* joyStick = _getSingleton().joySticks_[ID];
     1201    if (ID >= _getSingleton().joySticksSize_)
     1202      return false;
    11371203
    11381204    // see whether the handler already is in the list
    1139     for (std::vector<JoyStickHandler*>::iterator it = _getSingleton().activeJoyStickHandlers_[joyStick].begin();
    1140           it != _getSingleton().activeJoyStickHandlers_[joyStick].end(); it++)
     1205    for (std::vector<JoyStickHandler*>::iterator it = _getSingleton().activeJoyStickHandlers_[ID].begin();
     1206          it != _getSingleton().activeJoyStickHandlers_[ID].end(); it++)
    11411207    {
    11421208      if ((*it) == (*handlerIt).second)
  • code/trunk/src/core/InputManager.h

    r1219 r1293  
    3939
    4040#include <map>
    41 #include <list>
     41#include <vector>
    4242
    4343#include "ois/OIS.h"
    4444#include "Tickable.h"
     45#include "InputInterfaces.h"
    4546
    4647namespace orxonox
    4748{
    48   class Mouse : public OIS::Mouse
    49   {
    50   };
    51 
    5249  /**
    5350    @brief Captures and distributes mouse and keyboard input.
    5451  */
    5552  class _CoreExport InputManager
    56         : public Tickable,
     53        : public TickableReal,
    5754          public OIS::KeyListener, public OIS::MouseListener, public OIS::JoyStickListener
    5855  {
     
    7269
    7370  public: // static functions
    74     static bool initialise(const size_t windowHnd, const int windowWidth, const int windowHeight,
    75           const bool createKeyboard = true, const bool createMouse = true, const bool createJoySticks = false);
     71    static bool initialise(const size_t windowHnd, int windowWidth, int windowHeight,
     72          bool createKeyboard = true, bool createMouse = true, bool createJoySticks = false);
    7673    static bool initialiseKeyboard();
    7774    static bool initialiseMouse();
     
    8582    static void destroyMouse();
    8683    static void destroyJoySticks();
     84
     85    static bool isModifierDown(KeyboardModifier::Enum modifier);
     86    static bool isKeyDown(KeyCode::Enum key);
     87    static const MouseState getMouseState();
     88    static const JoyStickState getJoyStickState(unsigned int ID);
    8789
    8890    static void setWindowExtents(const int width, const int height);
     
    108110    static bool removeJoyStickHandler         (const std::string& name);
    109111    static JoyStickHandler* getJoyStickHandler(const std::string& name);
    110     static bool enableJoyStickHandler         (const std::string& name, const int id);
    111     static bool disableJoyStickHandler        (const std::string& name, const int id);
    112     static bool isJoyStickHandlerActive       (const std::string& name, const int id);
    113 
    114     // Temporary solutions. Will be removed soon!
    115     static OIS::Mouse*    getMouse()    { return _getSingleton().mouse_   ; }
    116     static OIS::Keyboard* getKeyboard() { return _getSingleton().keyboard_; }
     112    static bool enableJoyStickHandler         (const std::string& name, unsigned int id);
     113    static bool disableJoyStickHandler        (const std::string& name, unsigned int id);
     114    static bool isJoyStickHandlerActive       (const std::string& name, unsigned int id);
    117115
    118116  private: // functions
     
    123121
    124122    // Intenal methods
    125     bool _initialise(const size_t, const int, const int, const bool, const bool, const bool);
     123    bool _initialise(const size_t, int, int, bool, bool, bool);
    126124    bool _initialiseKeyboard();
    127125    bool _initialiseMouse();
     
    133131    void _destroyJoySticks();
    134132
    135     //void _setNumberOfJoysticks(int size);
    136 
    137133    void tick(float dt);
    138134
    139135    // input events
    140                 bool mousePressed  (const OIS::MouseEvent    &arg, OIS::MouseButtonID id);
    141                 bool mouseReleased (const OIS::MouseEvent    &arg, OIS::MouseButtonID id);
     136    bool mousePressed  (const OIS::MouseEvent    &arg, OIS::MouseButtonID id);
     137    bool mouseReleased (const OIS::MouseEvent    &arg, OIS::MouseButtonID id);
    142138    bool mouseMoved    (const OIS::MouseEvent    &arg);
    143                 bool keyPressed    (const OIS::KeyEvent      &arg);
    144                 bool keyReleased   (const OIS::KeyEvent      &arg);
    145                 bool buttonPressed (const OIS::JoyStickEvent &arg, int button);
    146                 bool buttonReleased(const OIS::JoyStickEvent &arg, int button);
    147                 bool axisMoved     (const OIS::JoyStickEvent &arg, int axis);
    148                 bool sliderMoved   (const OIS::JoyStickEvent &arg, int id);
    149                 bool povMoved      (const OIS::JoyStickEvent &arg, int id);
    150                 bool vector3Moved  (const OIS::JoyStickEvent &arg, int id);
     139    bool keyPressed    (const OIS::KeyEvent      &arg);
     140    bool keyReleased   (const OIS::KeyEvent      &arg);
     141    bool buttonPressed (const OIS::JoyStickEvent &arg, int button);
     142    bool buttonReleased(const OIS::JoyStickEvent &arg, int button);
     143    bool axisMoved     (const OIS::JoyStickEvent &arg, int axis);
     144    bool sliderMoved   (const OIS::JoyStickEvent &arg, int id);
     145    bool povMoved      (const OIS::JoyStickEvent &arg, int id);
     146    bool vector3Moved  (const OIS::JoyStickEvent &arg, int id);
    151147
    152148    static InputManager& _getSingleton();
     
    158154    OIS::Mouse*                                 mouse_;       //!< OIS keyboard
    159155    std::vector<OIS::JoyStick*>                 joySticks_;   //!< OIS joy sticks
     156    unsigned int                                joySticksSize_;
    160157
    161158    InputState state_;
    162159    InputState stateRequest_;
     160    unsigned int keyboardModifiers_;
    163161
    164162    std::map<std::string, KeyHandler*>          keyHandlers_;
     
    168166    std::vector<KeyHandler*>                    activeKeyHandlers_;
    169167    std::vector<MouseHandler*>                  activeMouseHandlers_;
    170     std::map< OIS::JoyStick*, std::vector<JoyStickHandler*> > activeJoyStickHandlers_;
     168    std::vector<std::vector<JoyStickHandler*> > activeJoyStickHandlers_;
    171169
    172     std::list<OIS::KeyCode>                     keysDown_;
    173     std::list<OIS::MouseButtonID>               mouseButtonsDown_;
    174     std::map< OIS::JoyStick*, std::list<int> >  joyStickButtonsDown_;
     170    std::vector<Key>                            keysDown_;
     171    std::vector<MouseButton::Enum>              mouseButtonsDown_;
     172    std::vector<std::vector<int> >              joyStickButtonsDown_;
    175173
    176174  };
     175
    177176}
    178177
  • code/trunk/src/core/Namespace.cc

    r1062 r1293  
    3737    CreateFactory(Namespace);
    3838
    39     Namespace::Namespace()
     39    Namespace::Namespace() :
     40      bAutogeneratedFileRootNamespace_(false),
     41      bRoot_(false),
     42      operator_("or")
    4043    {
    4144        RegisterObject(Namespace);
    42 
    43         this->bAutogeneratedFileRootNamespace_ = false;
    44         this->bRoot_ = false;
    45         this->operator_ = "or";
    4645    }
    4746
  • code/trunk/src/core/OrxonoxClass.cc

    r1056 r1293  
    3737{
    3838    /** @brief Constructor: Sets the default values. */
    39     OrxonoxClass::OrxonoxClass()
     39    OrxonoxClass::OrxonoxClass() :
     40      identifier_(0),
     41      parents_(0)
    4042    {
    4143        this->setConfigValues();
    42 
    43         this->identifier_ = 0;
    44         this->parents_ = 0;
    4544    }
    4645
  • code/trunk/src/core/SignalHandler.cc

    r1062 r1293  
    3535
    3636#include <assert.h>
     37#include <iostream>
    3738
    3839#include "Debug.h"
     
    4344
    4445#include <wait.h>
     46#include <X11/Xlib.h>
     47#include <X11/Xutil.h>
     48#include <X11/keysym.h>
     49
     50bool SignalHandler::bXAutoKeyRepeatOn_ = false;
    4551
    4652SignalHandler::SignalHandler()
     
    5864  this->fileName = fileName;
    5965
     66  // prepare for restoring XAutoKeyRepeat
     67  Display* display;
     68  if ((display = XOpenDisplay(0)))
     69  {
     70    XKeyboardState oldState;
     71    XGetKeyboardControl(display, &oldState);
     72    if (oldState.global_auto_repeat == AutoRepeatModeOn)
     73      bXAutoKeyRepeatOn_ = true;
     74    else
     75      bXAutoKeyRepeatOn_ = false;
     76    XCloseDisplay(display);
     77  }
     78  else
     79  {
     80    std::cout << "Warning: couldn't open X display to restore XAutoKeyRepeat." << std::endl;
     81    bXAutoKeyRepeatOn_ = false;
     82  }
     83
     84
    6085  // make sure doCatch is only called once without calling dontCatch
    6186  assert( sigRecList.size() == 0 );
     
    120145      sigName = "SIGILL";
    121146      break;
     147  }
     148
     149  if (bXAutoKeyRepeatOn_)
     150  {
     151    std::cout << "Trying to restore XAutoKeyRepeat" << std::endl;
     152        Display* display;
     153          if ((display = XOpenDisplay(0)))
     154    {
     155                        XAutoRepeatOn(display);
     156                  XCloseDisplay(display);
     157    }
    122158  }
    123159
  • code/trunk/src/core/SignalHandler.h

    r1062 r1293  
    8686    std::string appName;
    8787    std::string fileName;
     88
     89    // used to turn on KeyAutoRepeat if OIS crashes
     90    static bool bXAutoKeyRepeatOn_;
    8891};
    8992
  • code/trunk/src/core/Tickable.cc

    r1062 r1293  
    4040        RegisterRootObject(Tickable);
    4141    }
     42
     43    /**
     44        @brief Constructor: Registers the object in the TickableReal-list
     45    */
     46    TickableReal::TickableReal()
     47    {
     48        RegisterRootObject(TickableReal);
     49    }
    4250}
  • code/trunk/src/core/Tickable.h

    r1062 r1293  
    6262    };
    6363
     64    //! The Tickable interface provides a tick(dt) function, that gets called every frame.
     65    class _CoreExport TickableReal : virtual public OrxonoxClass
     66    {
     67        public:
     68            /**
     69                @brief Gets called every frame.
     70                @param dt The time since the last frame in seconds
     71            */
     72            virtual void tick(float dt) = 0;
     73
     74        protected:
     75            TickableReal();
     76    };
     77
    6478}
    6579
Note: See TracChangeset for help on using the changeset viewer.