Changeset 1520 for code/branches/input/src

Timestamp:

Jun 2, 2008, 10:34:20 PM (16 years ago)

Author:

rgrieder

Message:

split KeyBinder into multiple files instead of one unreadable monster file

Location:

code/branches/input/src/core

Files:

• CMakeLists.txt (modified) (1 diff)
• CorePrereqs.h (modified) (1 diff)
• input/Button.cc (added)
• input/Button.h (added)
• input/CalibratorCallback.cc (added)
• input/CalibratorCallback.h (added)
• input/HalfAxis.cc (added)
• input/HalfAxis.h (added)
• input/InputCommands.cc (added)
• input/InputCommands.h (added)
• input/InputManager.cc (modified) (2 diffs)
• input/KeyBinder.cc (modified) (2 diffs)
• input/KeyBinder.h (modified) (2 diffs)
• input/KeyDetector.cc (added)
• input/KeyDetector.h (added)

code/branches/input/src/core/CMakeLists.txt

@@ -31 +31 @@
   TclThreadManager.cc
   IRC.cc
+
+  input/Button.cc
+  input/CalibratorCallback.cc
+  input/HalfAxis.cc
   input/InputBuffer.cc
+  input/InputCommands.cc
   input/InputManager.cc
   input/KeyBinder.cc
+  input/KeyDetector.cc
+
   tolua/tolua_bind.cc
 )

code/branches/input/src/core/CorePrereqs.h

@@ -162 +162 @@
   // input
   //class GUIInputHandler;
-  class Calibrator;
+  class BaseCommand;
+  class BufferedParamCommand;
+  class Button;
   class CalibratorCallback;
+  class HalfAxis;
   class InputBuffer;
-  class InputBufferListener;
   class InputManager;
   class JoyStickHandler;
+  class MouseHandler;
   class KeyBinder;
   class KeyDetector;
-  class MouseHandler;
-
+  class KeyHandler;
+  class ParamCommand;
+  class SimpleCommand;
 }
 

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

@@ -35 +35 @@
 #include "InputManager.h"
 
-#include "util/Convert.h"
+#include <limits.h>
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
@@ -41 +41 @@
 #include "core/CommandExecutor.h"
 #include "core/ConsoleCommand.h"
-#include "core/Shell.h"
+#include "core/Shell.h"               // hack!
 #include "InputBuffer.h"
 #include "KeyBinder.h"
+#include "KeyDetector.h"
+#include "CalibratorCallback.h"
 
 namespace orxonox

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

@@ -34 +34 @@
 #include "KeyBinder.h"
 #include <fstream>
-#include <limits.h>
+#include <string>
 #include "util/Convert.h"
-#include "util/SubString.h"
-#include "util/String.h"
 #include "core/Debug.h"
 #include "core/ConfigValueIncludes.h"
 #include "core/CoreIncludes.h"
-#include "core/CommandExecutor.h"
-#include "core/ConsoleCommand.h"
-#include "core/Executor.h"
-// TODO: only needed by the CalibratorCallback class; move to new file
-#include "InputManager.h"
+#include "InputCommands.h"
 
 namespace orxonox
 {
-  // ###############################
-  // ###  BufferedParamCommand   ###
-  // ###############################
-
-  /**
-  * Executes a buffered command. This is used for commands with additional
-  * parameters.
-  * @return True if command execution was successful or value was zero.
-  */
-  bool BufferedParamCommand::execute()
-  {
-    if (nValuesAdded_)
-    {
-      BufferedParamCommand& cmd = *this;
-      cmd.evaluation_.setEvaluatedParameter(cmd.paramIndex_, cmd.value_);
-      // reset
-      cmd.nValuesAdded_ = 0;
-      cmd.value_ = 0;
-      return cmd.evaluation_.execute();
-    }
-    else
-      return true;
-  }
-
-  // ###############################
-  // #####    SimpleCommand    #####
-  // ###############################
-
-  /**
-  * Executes a simple command with no additional paramters.
-  * @return True if command execution was successful, false otherwise.
-  */
-  bool SimpleCommand::execute(float abs, float rel)
-  {
-    return evaluation_.execute();
-  }
-
-  // ###############################
-  // #####    ParamCommand     #####
-  // ###############################
-
-  /**
-  * Executes a parameter command. The commmand string is not directly executed,
-  * but instead stored in a buffer list so that values can be combined.
-  * @return Always true.
-  */
-  bool ParamCommand::execute(float abs, float rel)
-  {
-    BufferedParamCommand& cmd = *paramCommand_;
-    // command has an additional parameter
-    if (bRelative_)
-    {
-      if (rel != 0.0f)
-      {
-        // we have to calculate a relative movement.
-        // paramModifier_ says how much one keystroke is
-        cmd.value_ += paramModifier_ * rel;
-      }
-    }
-    else if (abs != 0.0f)
-    {
-      // Usually, joy sticks create 'noise' (they return values if they're in 0 position)
-      // and normally this is caught in tickInput(), but that threshold cannot be to high
-      // in order to preserve accuracy. Instead, we have to catch the problem here. An example:
-      // Someone only uses buttons with an active joystick. The joy stick value could then
-      // be 0.05 for instance and the the key value 1. Without handling the problem, the final
-      // value would be computed to (1+0.05)/2=0.5025 which is not what the user expects.
-      float absQ = abs * abs;
-      float valueQ = cmd.value_ * cmd.value_;
-      if (absQ > 50.0f * valueQ) // ease up comparison by using quadratics
-      {
-        cmd.value_ = abs * paramModifier_;
-        cmd.nValuesAdded_ = 1;
-      }
-      else if (absQ * 50.0f < valueQ)
-      {
-        // abs is too small, we just don't do anything
-      }
-      else
-      {
-        // we have to calculate the absolute position of the axis.
-        // Since there might be another axis that is affected, we have to wait and
-        // store the result in a temporary place
-        cmd.value_ = (cmd.value_ * cmd.nValuesAdded_ + paramModifier_ * abs) / ++cmd.nValuesAdded_;
-      }
-    }
-    return true;
-  }
-
-  // ###############################
-  // #####       Button        #####
-  // ###############################
-
-  void Button::clear()
-  {
-    for (unsigned int j = 0; j < 3; j++)
-    {
-      if (nCommands_[j])
-      {
-        // delete all commands and the command pointer array
-        for (unsigned int i = 0; i < nCommands_[j]; i++)
-          delete commands_[j][i];
-        delete[] commands_[j];
-        commands_[j] = 0;
-        nCommands_[j] = 0;
-      }
-      else
-      {
-        commands_[j] = 0;
-      }
-    }
-  }
-
-  void Button::parse(std::vector<BufferedParamCommand*>& paramCommandBuffer)
-  {
-    if (isEmpty(bindingString_))
-    {
-      clear();
-      return;
-    }
-
-    // use std::vector for a temporary dynamic array
-    std::vector<BaseCommand*> commands[3];
-
-
-    // separate the commands
-    SubString commandStrings(bindingString_, "|", SubString::WhiteSpaces, false,
-        '\\', false, '"', false, '(', ')', false, '\0');
-
-    for (unsigned int iCommand = 0; iCommand < commandStrings.size(); iCommand++)
-    {
-      if (commandStrings[iCommand] != "")
-      {
-        SubString tokens(commandStrings[iCommand], " ", SubString::WhiteSpaces, false,
-            '\\', false, '"', false, '(', ')', false, '\0');
-
-        unsigned int iToken = 0;
-
-        // for real axes, we can feed a ButtonThreshold argument as entire command
-        if (getLowercase(tokens[0]) == "buttonthreshold")
-        {
-          if (tokens.size() == 1)
-            continue;
-          // may fail, but doesn't matter
-          convertValue(&buttonThreshold_, tokens[1]);
-          continue;
-        }
-
-        // first argument can be OnPress, OnHold OnRelease or nothing
-        KeybindMode::Enum mode = KeybindMode::None;
-        if (getLowercase(tokens[iToken]) == "onpress")
-          mode = KeybindMode::OnPress,   iToken++;
-        if (getLowercase(tokens[iToken]) == "onrelease")
-          mode = KeybindMode::OnRelease, iToken++;
-        if (getLowercase(tokens[iToken]) == "onhold")
-          mode = KeybindMode::OnHold,    iToken++;
-
-        if (iToken == tokens.size())
-          continue;
-
-        // second argument can be the amplitude for the case it as an axis command
-        // default amplitude is 1.0f
-        float paramModifier = 1.0f;
-        if (getLowercase(tokens[iToken]) == "scale")
-        {
-          iToken++;
-          if (iToken == tokens.size() || !convertValue(&paramModifier, tokens[iToken]))
-          {
-            COUT(2) << "Error while parsing key binding " << name_
-                << ". Numeric expression expected afer 'AxisAmp', switching to default value" << std::endl;
-            if (iToken == tokens.size())
-              continue;
-          }
-          iToken++;
-        }
-
-        // no more arguments expected except for the actual command
-        if (iToken == tokens.size())
-          continue;
-
-        std::string commandStr;
-        while (iToken != tokens.size())
-          commandStr += tokens[iToken++] + " ";
-
-        // evaluate the command
-        CommandEvaluation eval = CommandExecutor::evaluate(commandStr);
-        if (!eval.isValid())
-          continue;
-
-        // check for param command
-        int paramIndex = eval.getConsoleCommand()->getAxisParamIndex();
-        if (paramIndex >= 0)
-        {
-          // parameter supported command
-          ParamCommand* cmd = new ParamCommand();
-          cmd->paramModifier_ = paramModifier;
-          cmd->bRelative_ = eval.getConsoleCommand()->getIsAxisRelative();
-
-          // add command to the buffer if not yet existing
-          for (unsigned int iParamCmd = 0; iParamCmd < paramCommandBuffer.size(); iParamCmd++)
-          {
-            if (getLowercase(paramCommandBuffer[iParamCmd]->evaluation_.getOriginalCommand())
-                == getLowercase(commandStr))
-            {
-              // already in list
-              cmd->paramCommand_ = paramCommandBuffer[iParamCmd];
-              break;
-            }
-          }
-          if (cmd->paramCommand_ == 0)
-          {
-            cmd->paramCommand_ = new BufferedParamCommand();
-            paramCommandBuffer.push_back(cmd->paramCommand_);
-            cmd->paramCommand_->evaluation_ = eval;
-            cmd->paramCommand_->paramIndex_ = paramIndex;
-          }
-
-
-          // we don't know whether this is an actual axis or just a button
-          if (mode == KeybindMode::None)
-          {
-            if (!addParamCommand(cmd))
-            {
-              mode = eval.getConsoleCommand()->getKeybindMode();
-              commands[mode].push_back(cmd);
-            }
-          }
-        }
-        else
-        {
-          SimpleCommand* cmd = new SimpleCommand();
-          cmd->evaluation_ = eval;
-
-          if (mode == KeybindMode::None)
-            mode = eval.getConsoleCommand()->getKeybindMode();
-
-          commands[mode].push_back(cmd);
-        }
-      }
-    }
-
-    for (unsigned int j = 0; j < 3; j++)
-    {
-      nCommands_[j] = commands[j].size();
-      if (nCommands_[j])
-      {
-        commands_[j] = new BaseCommand*[nCommands_[j]];
-        for (unsigned int i = 0; i < commands[j].size(); i++)
-          commands_[j][i] = commands[j][i];
-      }
-      else
-        commands_[j] = 0;
-    }
-  }
-
-  bool Button::execute(KeybindMode::Enum mode, float abs, float rel)
-  {
-    // execute all the parsed commands in the string
-    for (unsigned int iCommand = 0; iCommand < nCommands_[mode]; iCommand++)
-      commands_[mode][iCommand]->execute(abs, rel);
-    return true;
-  }
-
-  // ###############################
-  // #####      HalfAxis       #####
-  // ###############################
-
-  void HalfAxis::clear()
-  {
-    Button::clear();
-    if (nParamCommands_)
-    {
-      // delete all commands and the command pointer array
-      for (unsigned int i = 0; i < nParamCommands_; i++)
-        delete paramCommands_[i];
-      delete[] paramCommands_;
-      nParamCommands_ = 0;
-    }
-    else
-    {
-      nParamCommands_ = 0; nParamCommands_ = 0;
-    }
-  }
-
-  bool HalfAxis::addParamCommand(ParamCommand* command)
-  {
-    ParamCommand** cmds = paramCommands_;
-    paramCommands_ = new ParamCommand*[++nParamCommands_];
-    unsigned int i;
-    for (i = 0; i < nParamCommands_ - 1; i++)
-      paramCommands_[i] = cmds[i];
-    paramCommands_[i] = command;
-    if (nParamCommands_ > 1)
-      delete[] cmds;
-    return true;
-  }
-
-  bool HalfAxis::execute()
-  {
-    bool success = true;
-    for (unsigned int i = 0; i < nParamCommands_; i++)
-      success = success && paramCommands_[i]->execute(absVal_, relVal_);
-    return success;
-  }
-
-
-  // ###############################
-  // ######     KeyBinder     ######
-  // ###############################
-
   /**
     @brief Constructor that does as little as necessary.
@@ -854 +538 @@
     }
   }
-
-
-  // ###############################
-  // #####     KeyDetector     #####
-  // ###############################
-
-  /**
-    @brief Constructor
-  */
-  KeyDetector::KeyDetector()
-  {
-    RegisterObject(KeyDetector);
-  }
-
-  /**
-    @brief Destructor
-  */
-  KeyDetector::~KeyDetector()
-  {
-  }
-
-  /**
-    @brief Loads the key and button bindings.
-    @return True if loading succeeded.
-  */
-  void KeyDetector::loadBindings()
-  {
-    clearBindings();
-    setConfigValues();
-  }
-
-  void KeyDetector::readTrigger(Button& button)
-  {
-    SimpleCommand* cmd = new SimpleCommand();
-    cmd->evaluation_ = CommandExecutor::evaluate("storeKeyStroke " + button.name_);
-    button.commands_[KeybindMode::OnPress] = new BaseCommand*[1];
-    button.commands_[KeybindMode::OnPress][0] = cmd;
-    button.nCommands_[KeybindMode::OnPress] = 1;
-  }
-
-
-  // ###############################
-  // ##### CalibratorCallback  #####
-  // ###############################
-
-  void CalibratorCallback::keyPressed(const orxonox::KeyEvent &evt)
-  {
-    if (evt.key == KeyCode::Return)
-    {
-      InputManager::setInputState(InputManager::IS_NOCALIBRATE);
-    }
-  }
 }

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

@@ -37 +37 @@
 #include "core/CorePrereqs.h"
 
-#include <string>
 #include <vector>
 
-#include "ois/OIS.h"
-#include "util/Math.h"
 #include "core/OrxonoxClass.h"
-#include "core/CommandEvaluation.h"
 #include "InputInterfaces.h"
+#include "Button.h"
+#include "HalfAxis.h"
 
 namespace orxonox
 {
-  class _CoreExport BufferedParamCommand
-  {
-  public:
-    BufferedParamCommand() : value_(0.0f), nValuesAdded_(0), paramIndex_(-1) { }
-    bool execute();
-
-    float value_;
-    unsigned int nValuesAdded_;
-    int paramIndex_;
-    CommandEvaluation evaluation_;
-  };
-
-  class _CoreExport BaseCommand
-  {
-  public:
-    virtual ~BaseCommand() { }
-    virtual bool execute(float abs = 1.0f, float rel = 1.0f) = 0;
-  };
-
-  class _CoreExport SimpleCommand : public BaseCommand
-  {
-  public:
-    bool execute(float abs = 1.0f, float rel = 1.0f);
-
-    CommandEvaluation evaluation_;
-  };
-
-  class _CoreExport ParamCommand : public BaseCommand
-  {
-  public:
-    ParamCommand() : bRelative_(false), paramModifier_(1.0f), paramCommand_(0) { }
-    bool execute(float abs = 1.0f, float rel = 1.0f);
-
-    bool bRelative_;
-    float paramModifier_;
-    BufferedParamCommand* paramCommand_;
-  };
-
-  class _CoreExport Button
-  {
-  public:
-    Button() { nCommands_[0]=0; nCommands_[1]=0; nCommands_[2]=0; clear(); }
-    virtual ~Button() { clear(); }
-    virtual void clear();
-    virtual bool addParamCommand(ParamCommand* command) { return false; }
-    void parse(std::vector<BufferedParamCommand*>& paramCommandBuffer);
-    bool execute(KeybindMode::Enum mode, float abs = 1.0f, float rel = 1.0f);
-
-    //! The configured string value
-    std::string bindingString_;
-    //! Name of the trigger as strings
-    std::string name_;
-    //! Basic commands for OnPress, OnHold and OnRelease
-    BaseCommand** commands_[3];
-    //! Number of basic commands
-    unsigned int nCommands_[3];
-    //! Says how much it takes for an analog axis to trigger a button
-    //! Note: This variable is here to have only one parse() function.
-    float buttonThreshold_;
-  };
-
-
-  class _CoreExport HalfAxis : public Button
-  {
-  public:
-    HalfAxis() : relVal_(0.0f), absVal_(0.0f), paramCommands_(0), nParamCommands_(0),
-                 wasDown_(false), hasChanged_(false) { }
-    using Button::execute;
-    bool execute();
-    //bool execute(KeybindMode::Enum mode) { return Button::execute(mode); }
-    bool addParamCommand(ParamCommand* command);
-    void clear();
-
-    // axis related
-    float relVal_;
-    float absVal_;
-    ParamCommand** paramCommands_;
-    unsigned int nParamCommands_;
-
-    // button related
-    bool wasDown_;
-    bool hasChanged_;
-  };
-
-
   /**
     @brief Handles mouse, keyboard and joy stick input while in the actual game mode.
@@ -226 +139 @@
     bool bClipMouse_;
   };
-
-
-  class _CoreExport KeyDetector : public KeyBinder
-  {
-  public:
-    KeyDetector();
-    ~KeyDetector();
-    void loadBindings();
-
-  protected:
-    void readTrigger(Button& button);
-  };
-
-  class _CoreExport CalibratorCallback : public KeyHandler
-  {
-  public:
-    CalibratorCallback() {}
-    ~CalibratorCallback() {}
-
-  private:
-    void keyPressed (const KeyEvent& evt);
-    void keyReleased(const KeyEvent& evt) {}
-    void keyHeld    (const KeyEvent& evt) {}
-
-    void tickInput(float dt, const HandlerState &state) { }
-  };
 }
 
-
-
-
 #endif /* _KeyBinder_H__ */