Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
May 19, 2008, 10:50:09 AM (17 years ago)
Author:
rgrieder
Message:

Basically, almost everything about the input management is written, but I wasn't yet able to test things.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • code/branches/input/src/core/InputHandler.cc

    r1293 r1323  
    3434#include "InputHandler.h"
    3535#include "util/Convert.h"
     36#include "util/SubString.h"
     37#include "util/String.h"
    3638#include "Debug.h"
    3739#include "ConfigValueIncludes.h"
    3840#include "CoreIncludes.h"
    3941#include "CommandExecutor.h"
     42#include "Executor.h"
    4043
    4144namespace orxonox
    … …  
    5154  {
    5255    RegisterObject(KeyBinder);
    53     clearBindings();
    54 
     56    clearBindings(true);
     57
     58    // keys
    5559    std::string keyNames[] = {
    56     "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",
    140     "","",
    141     "OEM_102",
    142     "F11",
    143     "F12",
    144     "","","","","","","","","","","",
    145     "F13",
    146     "F14",
    147     "F15",
    148     "","","","","","","","","","",
    149     "KANA",
    150     "","",
    151     "ABNT_C1",
    152     "","","","","",
    153     "CONVERT",
    154     "",
    155     "NOCONVERT",
    156     "",
    157     "YEN",
    158     "ABNT_C2",
    159     "","","","","","","","","","","","","","",
    160     "NUMPADEQUALS",
    161     "","",
    162     "PREVTRACK",
    163     "AT",
    164     "COLON",
    165     "UNDERLINE",
    166     "KANJI",
    167     "STOP",
    168     "AX",
    169     "UNLABELED",
    170     "NEXTTRACK",
    171     "","",
    172     "NUMPADENTER",
    173     "RCONTROL",
    174     "","",
    175     "MUTE",
    176     "CALCULATOR",
    177     "PLAYPAUSE",
    178     "",
    179     "MEDIASTOP",
    180     "","","","","","","","","",
    181     "VOLUMEDOWN",
    182     "",
    183     "VOLUMEUP",
    184     "",
    185     "WEBHOME",
    186     "NUMPADCOMMA",
    187     "",
    188     "DIVIDE",
    189     "",
    190     "SYSRQ",
    191     "RMENU",
    192     "","","","","","","","","","","","",
    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",
    208     "","","","","","","",
    209     "LWIN",
    210     "RWIN",
    211     "APPS",
    212     "POWER",
    213     "SLEEP",
    214     "","","",
    215     "WAKE",
    216     "",
    217     "WEBSEARCH",
    218     "WEBFAVORITES",
    219     "WEBREFRESH",
    220     "WEBSTOP",
    221     "WEBFORWARD",
    222     "WEBBACK",
    223     "MYCOMPUTER",
    224     "MAIL",
    225     "MEDIASELECT"
     60      "UNASSIGNED",
     61      "ESCAPE",
     62      "1",
     63      "2",
     64      "3",
     65      "4",
     66      "5",
     67      "6",
     68      "7",
     69      "8",
     70      "9",
     71      "0",
     72      "MINUS",
     73      "EQUALS",
     74      "BACK",
     75      "TAB",
     76      "Q",
     77      "W",
     78      "E",
     79      "R",
     80      "T",
     81      "Y",
     82      "U",
     83      "I",
     84      "O",
     85      "P",
     86      "LBRACKET",
     87      "RBRACKET",
     88      "RETURN",
     89      "LCONTROL",
     90      "A",
     91      "S",
     92      "D",
     93      "F",
     94      "G",
     95      "H",
     96      "J",
     97      "K",
     98      "L",
     99      "SEMICOLON",
     100      "APOSTROPHE",
     101      "GRAVE",
     102      "LSHIFT",
     103      "BACKSLASH",
     104      "Z",
     105      "X",
     106      "C",
     107      "V",
     108      "B",
     109      "N",
     110      "M",
     111      "COMMA",
     112      "PERIOD",
     113      "SLASH",
     114      "RSHIFT",
     115      "MULTIPLY",
     116      "LMENU",
     117      "SPACE",
     118      "CAPITAL",
     119      "F1",
     120      "F2",
     121      "F3",
     122      "F4",
     123      "F5",
     124      "F6",
     125      "F7",
     126      "F8",
     127      "F9",
     128      "F10",
     129      "NUMLOCK",
     130      "SCROLL",
     131      "NUMPAD7",
     132      "NUMPAD8",
     133      "NUMPAD9",
     134      "SUBTRACT",
     135      "NUMPAD4",
     136      "NUMPAD5",
     137      "NUMPAD6",
     138      "ADD",
     139      "NUMPAD1",
     140      "NUMPAD2",
     141      "NUMPAD3",
     142      "NUMPAD0",
     143      "DECIMAL",
     144      "","",
     145      "OEM_102",
     146      "F11",
     147      "F12",
     148      "","","","","","","","","","","",
     149      "F13",
     150      "F14",
     151      "F15",
     152      "","","","","","","","","","",
     153      "KANA",
     154      "","",
     155      "ABNT_C1",
     156      "","","","","",
     157      "CONVERT",
     158      "",
     159      "NOCONVERT",
     160      "",
     161      "YEN",
     162      "ABNT_C2",
     163      "","","","","","","","","","","","","","",
     164      "NUMPADEQUALS",
     165      "","",
     166      "PREVTRACK",
     167      "AT",
     168      "COLON",
     169      "UNDERLINE",
     170      "KANJI",
     171      "STOP",
     172      "AX",
     173      "UNLABELED",
     174      "NEXTTRACK",
     175      "","",
     176      "NUMPADENTER",
     177      "RCONTROL",
     178      "","",
     179      "MUTE",
     180      "CALCULATOR",
     181      "PLAYPAUSE",
     182      "",
     183      "MEDIASTOP",
     184      "","","","","","","","","",
     185      "VOLUMEDOWN",
     186      "",
     187      "VOLUMEUP",
     188      "",
     189      "WEBHOME",
     190      "NUMPADCOMMA",
     191      "",
     192      "DIVIDE",
     193      "",
     194      "SYSRQ",
     195      "RMENU",
     196      "","","","","","","","","","","","",
     197      "PAUSE",
     198      "",
     199      "HOME",
     200      "UP",
     201      "PGUP",
     202      "",
     203      "LEFT",
     204      "",
     205      "RIGHT",
     206      "",
     207      "END",
     208      "DOWN",
     209      "PGDOWN",
     210      "INSERT",
     211      "DELETE",
     212      "","","","","","","",
     213      "LWIN",
     214      "RWIN",
     215      "APPS",
     216      "POWER",
     217      "SLEEP",
     218      "","","",
     219      "WAKE",
     220      "",
     221      "WEBSEARCH",
     222      "WEBFAVORITES",
     223      "WEBREFRESH",
     224      "WEBSTOP",
     225      "WEBFORWARD",
     226      "WEBBACK",
     227      "MYCOMPUTER",
     228      "MAIL",
     229      "MEDIASELECT"
    226230    };
    227     for (int i = 0; i < numberOfKeys_s; i++)
    228       keyNames_[i] = keyNames[i];
    229 
     231    for (int i = 0; i < nKeys_s; i++)
     232      namesKeys_[i] = "Key" + keyNames[i];
     233
     234    // mouse buttons
    230235    std::string mouseButtonNames[] = {
    231236      "MouseLeft", "MouseRight", "MouseMiddle",
    232237      "MouseButton3", "MouseButton4", "MouseButton5",
    233238      "MouseButton6", "MouseButton7" };
    234     for (int i = 0; i < numberOfMouseButtons_s; i++)
    235       mouseButtonNames_[i] = mouseButtonNames[i];
    236 
    237     for (int i = 0; i < numberOfJoyStickButtons_s; i++)
    238       joyStickButtonNames_[i] = "JoyStick" + getConvertedValue<int, std::string>(i);
     239    for (int i = 0; i < nMouseButtons_s; i++)
     240      namesMouseButtons_[i] = mouseButtonNames[i];
     241
     242    // joy stick buttons
     243    for (int i = 0; i < 32; i++)
     244      namesJoyStickButtons_[i] = "JoyButton" + getConvertedValue<int, std::string>(i);
     245    for (int i = 32; i < nJoyStickButtons_s; i += 4)
     246    {
     247                  namesJoyStickButtons_[i + 0] = "JoyPOV" + getConvertedValue<int, std::string>((i - 32)/4 + 1) + "North";
     248                  namesJoyStickButtons_[i + 1] = "JoyPOV" + getConvertedValue<int, std::string>((i - 32)/4 + 1) + "South";
     249                  namesJoyStickButtons_[i + 2] = "JoyPOV" + getConvertedValue<int, std::string>((i - 32)/4 + 1) + "East";
     250                  namesJoyStickButtons_[i + 3] = "JoyPOV" + getConvertedValue<int, std::string>((i - 32)/4 + 1) + "West";
     251    }
     252
     253    // half axes
     254    std::string rawNames[nHalfAxes_s/2];
     255    rawNames[0] = "MouseX";
     256    rawNames[1] = "MouseY";
     257    rawNames[2] = "MouseWheel1";
     258    rawNames[3] = "MouseWheel2";
     259    for (unsigned int i = 4; i < nHalfAxes_s/2; i++)
     260      rawNames[i] = "JoyAxis" + getConvertedValue<int, std::string>(i - 3);
     261    for (unsigned int i = 0; i < nHalfAxes_s/2; i++)
     262    {
     263      namesHalfAxes_[i * 2 + 0] = rawNames[i] + "Pos";
     264      namesHalfAxes_[i * 2 + 1] = rawNames[i] + "Neg";
     265    }
    239266  }
    240267
    … …  
    244271  KeyBinder::~KeyBinder()
    245272  {
     273    // almost no destructors required because most of the arrays are static.
     274    clearBindings(); // does some destruction work
    246275  }
    247276
    … …  
    251280  void KeyBinder::setConfigValues()
    252281  {
    253     ConfigValueContainer* cont;
    254     std::string modes[] = {"P_", "R_", "H_"};
    255 
     282    bool success = true;
    256283    // keys
    257     for (int i = 0; i < numberOfKeys_s; i++)
    258     {
    259       for (int j = 0; j < 3; j++)
    260       {
    261         cont = getIdentifier()->getConfigValueContainer(modes[j] + keyNames_[i]);
    262         if (!cont)
    263         {
    264           cont = new ConfigValueContainer(CFT_Keybindings, getIdentifier(), modes[j] + keyNames_[i], "");
    265           getIdentifier()->addConfigValueContainer(modes[j] + keyNames_[i], cont);
    266         }
    267         switch (j)
    268         {
    269           case 0:
    270             cont->getValue(&bindingsKeyPress_[i].commandStr);
    271             break;
    272           case 1:
    273             cont->getValue(&bindingsKeyRelease_[i].commandStr);
    274             break;
    275           case 2:
    276             cont->getValue(&bindingsKeyHold_[i].commandStr);
    277         }
    278       }
    279     }
    280 
     284    success |= readBindings(namesKeys_, bindingStringsKeys_, bindingsKeys_, nKeys_s);
    281285    // mouse buttons
    282     for (int i = 0; i < numberOfMouseButtons_s; i++)
    283     {
    284       for (int j = 0; j < 3; j++)
    285       {
    286         cont = getIdentifier()->getConfigValueContainer(modes[j] + mouseButtonNames_[i]);
    287         if (!cont)
    288         {
    289           cont = new ConfigValueContainer(CFT_Keybindings, getIdentifier(), modes[j] + mouseButtonNames_[i], "");
    290           getIdentifier()->addConfigValueContainer(modes[j] + mouseButtonNames_[i], cont);
    291         }
    292         switch (j)
    293         {
    294           case 0:
    295             cont->getValue(&bindingsMouseButtonPress_[i].commandStr);
    296             break;
    297           case 1:
    298             cont->getValue(&bindingsMouseButtonRelease_[i].commandStr);
    299             break;
    300           case 2:
    301             cont->getValue(&bindingsMouseButtonHold_[i].commandStr);
    302         }
    303       }
    304     }
    305 
     286    success |= readBindings(namesMouseButtons_, bindingStringsMouseButtons_, bindingsMouseButtons_, nMouseButtons_s);
    306287    // joy stick buttons
    307     for (int i = 0; i < numberOfJoyStickButtons_s; i++)
    308     {
    309       for (int j = 0; j < 3; j++)
    310       {
    311         cont = getIdentifier()->getConfigValueContainer(modes[j] + joyStickButtonNames_[i]);
    312         if (!cont)
    313         {
    314           cont = new ConfigValueContainer(CFT_Keybindings, getIdentifier(), modes[j] + joyStickButtonNames_[i], "");
    315           getIdentifier()->addConfigValueContainer(modes[j] + joyStickButtonNames_[i], cont);
    316         }
    317         switch (j)
    318         {
    319           case 0:
    320             cont->getValue(&bindingsJoyStickButtonPress_[i].commandStr);
    321             break;
    322           case 1:
    323             cont->getValue(&bindingsJoyStickButtonRelease_[i].commandStr);
    324             break;
    325           case 2:
    326             cont->getValue(&bindingsJoyStickButtonHold_[i].commandStr);
    327         }
    328       }
    329     }
     288    success |= readBindings(namesJoyStickButtons_, bindingStringsJoyStickButtons_,
     289        bindingsJoyStickButtons_, nJoyStickButtons_s);
     290    // half axes
     291    success |= readBindings(namesHalfAxes_, bindingStringsHalfAxes_, bindingsHalfAxes_, nHalfAxes_s);
     292   
     293    // TODO: what happens if parsing didn't succeed in all parts? nothing?
     294  }
     295
     296  bool KeyBinder::readBindings(std::string* names, std::string* bindingStrings,
     297      KeyBindingBundle* bindings, unsigned int size)
     298  {
     299    for (unsigned int i = 0; i < size; i++)
     300    {
     301      // config value stuff
     302      ConfigValueContainer* cont = getIdentifier()->getConfigValueContainer(names[i]);
     303      if (!cont)
     304      {
     305        cont = new ConfigValueContainer(CFT_Keybindings, getIdentifier(), names[i], "");
     306        getIdentifier()->addConfigValueContainer(names[i], cont);
     307      }
     308      std::string old = bindingStrings[i];
     309      cont->getValue(&bindingStrings[i]);
     310
     311      // keybinder stuff
     312      if (old != bindingStrings[i])
     313      {
     314        // binding has changed
     315        if (bindingStrings[i] == "")
     316        {
     317          // empty binding, occurs at least the first time since init value is " "
     318          bindings[i].OnPress.clear();
     319          bindings[i].OnRelease.clear();
     320          bindings[i].OnHold.clear();
     321        }
     322        else
     323        {
     324          // actually parse the command(s)
     325          SubString commands(bindingStrings[i], "|", SubString::WhiteSpaces, false,
     326              '\\', false, '"', false, '(', ')', false, '\0');
     327          bindings[i].OnHold.nCommands = 0;
     328          bindings[i].OnHold.commands = new SimpleCommand[64];
     329          bindings[i].OnPress.nCommands = 0;
     330          bindings[i].OnPress.commands = new SimpleCommand[64];
     331          bindings[i].OnRelease.nCommands = 0;
     332          bindings[i].OnRelease.commands = new SimpleCommand[64];
     333          for (unsigned int iCommand = 0; iCommand < commands.size(); iCommand++)
     334          {
     335            if (commands[iCommand] != "")
     336            {
     337              SubString tokens(commands[iCommand], " ", SubString::WhiteSpaces, false,
     338                  '\\', false, '"', false, '(', ')', false, '\0');
     339             
     340              unsigned int iToken = 0;
     341
     342              // first argument can be OnPress, OnHold OnRelease or nothing
     343              KeybindMode::Enum mode = KeybindMode::None;
     344              if (getLowercase(tokens[iToken]) == "onpress")
     345                mode = KeybindMode::OnPress,   iToken++;
     346              if (getLowercase(tokens[iToken]) == "onrelease")
     347                mode = KeybindMode::OnRelease, iToken++;
     348              if (getLowercase(tokens[iToken]) == "onhold")
     349                mode = KeybindMode::OnHold,    iToken++;
     350
     351              if (iToken == tokens.size())
     352                continue;
     353
     354              SimpleCommand* cmd = new SimpleCommand();
     355
     356              // second argument can be the amplitude for the case it as an axis command
     357              // default amplitude is 1.0f
     358              if (getLowercase(tokens[iToken]) == "axisamp")
     359              {
     360                iToken++;
     361                float value;
     362                if (iToken == tokens.size() || !convertValue(&value, tokens[iToken]))
     363                {
     364                  CCOUT(2) << "Error while parsing key binding " << names[i]
     365                      << ". Numeric expression expected afer 'AxisAmp', switching to default value" << std::endl;
     366                  if (iToken == tokens.size())
     367                  {
     368                    delete cmd;
     369                    continue;
     370                  }
     371                  cmd->axisModifier = 1.0f;
     372                }
     373                else
     374                  cmd->axisModifier = value;
     375                iToken++;
     376              }
     377              else
     378                cmd->axisModifier = 1.0f;
     379
     380              // no more arguments expected except for the actual command
     381              if (iToken == tokens.size())
     382              { // no command given
     383                delete cmd;
     384                continue;
     385              }
     386              while (iToken != tokens.size())
     387                cmd->commandStr += tokens[iToken++] + " ";
     388
     389              // check whether we exceed 64 commands...
     390              if (bindings[i].OnHold.nCommands == 64 || bindings[i].OnPress.nCommands == 64
     391                  || bindings[i].OnRelease.nCommands == 64)
     392              {
     393                CCOUT(2) << "Error while parsing key binding " << names[i]
     394                    << ". You shouldn't assign more than 64 key bindings to one key "
     395                    << "just to test the parser" << std::endl;
     396              }
     397
     398              // evaluate the command
     399              cmd->axisCommand = 0;
     400              CommandEvaluation& eval = CommandExecutor::evaluate(cmd->commandStr);
     401              // TOOD: check for axis command
     402              if (false)
     403              {
     404                cmd->axisCommand->commandStr = cmd->commandStr;
     405                cmd->commandStr = "";
     406                cmd->axisCommand->evaluation = eval;
     407                // add command to the buffer if not yet existing
     408                for (unsigned int iAxisCmd = 0; iAxisCmd < axisCommands_.size(); iAxisCmd++)
     409                {
     410                  if (getLowercase(axisCommands_[iAxisCmd]->commandStr) == getLowercase(cmd->commandStr))
     411                  {
     412                    // already in list
     413                    cmd->axisCommand = axisCommands_[iAxisCmd];
     414                    break;
     415                  }
     416                }
     417                if (cmd->axisCommand == 0)
     418                {
     419                  cmd->axisCommand = new AxisCommand();
     420                  axisCommands_.push_back(cmd->axisCommand);
     421                }
     422                // TODO: check for relative/absolute command
     423                cmd->axisCommand->bRelative = false;
     424
     425                // axis commands are always OnHold
     426                *(bindings[i].OnHold.commands + bindings[i].OnHold.nCommands++) = *cmd;
     427              }
     428              else
     429              {
     430                cmd->evaluation = eval;
     431
     432                // TODO: determine whether the command is OnHold, OnPress or OnRelease
     433                switch (mode)
     434                {
     435                case KeybindMode::None:
     436                  *(bindings[i].OnPress.commands + bindings[i].OnPress.nCommands++) = *cmd;
     437                  break;
     438                case KeybindMode::OnPress:
     439                  *(bindings[i].OnPress.commands + bindings[i].OnPress.nCommands++) = *cmd;
     440                  break;
     441                case KeybindMode::OnHold:
     442                  *(bindings[i].OnHold.commands + bindings[i].OnHold.nCommands++) = *cmd;
     443                  break;
     444                case KeybindMode::OnRelease:
     445                  *(bindings[i].OnRelease.commands + bindings[i].OnRelease.nCommands++) = *cmd;
     446                  break;                     
     447                }
     448              }
     449            }
     450          }
     451
     452          // redimension arrays with simple commands
     453          SimpleCommand* sCmd = bindings[i].OnHold.commands;
     454          if (bindings[i].OnHold.nCommands)
     455          {
     456            bindings[i].OnHold.commands = new SimpleCommand[bindings[i].OnHold.nCommands];
     457            for (unsigned int iCmd = 0; iCmd < bindings[i].OnHold.nCommands; iCmd++)
     458              bindings[i].OnHold.commands[iCmd] = sCmd[iCmd];
     459          }
     460          else
     461            bindings[i].OnHold.commands = 0;
     462          delete[] sCmd;
     463
     464          sCmd = bindings[i].OnPress.commands;
     465          if (bindings[i].OnPress.nCommands)
     466          {
     467            bindings[i].OnPress.commands = new SimpleCommand[bindings[i].OnPress.nCommands];
     468            for (unsigned int iCmd = 0; iCmd < bindings[i].OnPress.nCommands; iCmd++)
     469              bindings[i].OnPress.commands[iCmd] = sCmd[iCmd];
     470          }
     471          else
     472            bindings[i].OnPress.commands = 0;
     473          delete[] sCmd;
     474
     475          sCmd = bindings[i].OnRelease.commands;
     476          if (bindings[i].OnRelease.nCommands)
     477          {
     478            bindings[i].OnRelease.commands = new SimpleCommand[bindings[i].OnRelease.nCommands];
     479            for (unsigned int iCmd = 0; iCmd < bindings[i].OnRelease.nCommands; iCmd++)
     480              bindings[i].OnRelease.commands[iCmd] = sCmd[iCmd];
     481          }
     482          else
     483            bindings[i].OnRelease.commands = 0;
     484          delete[] sCmd;
     485        }
     486      }
     487    }
     488    return true;
    330489  }
    331490
    … …  
    333492    @brief Overwrites all bindings with ""
    334493  */
    335   void KeyBinder::clearBindings()
    336   {
    337     for (int i = 0; i < numberOfKeys_s; i++)
    338     {
    339       bindingsKeyPress_  [i].commandStr = "";
    340       bindingsKeyRelease_[i].commandStr = "";
    341       bindingsKeyHold_   [i].commandStr = "";
    342     }
    343     for (int i = 0; i < numberOfMouseButtons_s; i++)
    344     {
    345       bindingsMouseButtonPress_  [i].commandStr = "";
    346       bindingsMouseButtonRelease_[i].commandStr = "";
    347       bindingsMouseButtonHold_   [i].commandStr = "";
    348     }
    349     for (int i = 0; i < numberOfJoyStickButtons_s; i++)
    350     {
    351       bindingsJoyStickButtonPress_  [i].commandStr = "";
    352       bindingsJoyStickButtonRelease_[i].commandStr = "";
    353       bindingsJoyStickButtonHold_   [i].commandStr = "";
    354     }
     494  void KeyBinder::clearBindings(bool bInit)
     495  {
     496    for (int i = 0; i < nKeys_s; i++)
     497    {
     498      clearBundle(bindingsKeys_[i], bInit);
     499      bindingStringsKeys_[i] = " ";
     500    }
     501    for (int i = 0; i < nMouseButtons_s; i++)
     502    {
     503      clearBundle(bindingsMouseButtons_[i], bInit);
     504      bindingStringsMouseButtons_[i] = " ";
     505    }
     506    for (int i = 0; i < nJoyStickButtons_s; i++)
     507    {
     508      clearBundle(bindingsJoyStickButtons_[i], bInit);
     509      bindingStringsJoyStickButtons_[i] = " ";
     510    }
     511    for (int i = 0; i < nHalfAxes_s; i++)
     512    {
     513      clearBundle(bindingsHalfAxes_[i], bInit);
     514      bindingStringsHalfAxes_[i] = " ";
     515    }
     516    for (unsigned int i = 0; i < axisCommands_.size(); i++)
     517      delete axisCommands_[i];
     518    axisCommands_.clear();
     519  }
     520
     521  void KeyBinder::clearBundle(KeyBindingBundle& bundle, bool bInit)
     522  {
     523    if (!bInit)
     524    {
     525      if (bundle.OnHold.nCommands)
     526        delete[] bundle.OnHold.commands;
     527      if (bundle.OnPress.nCommands)
     528        delete[] bundle.OnPress.commands;
     529      if (bundle.OnRelease.nCommands)
     530        delete[] bundle.OnRelease.commands;
     531    }
     532    bundle.OnPress.nCommands = 0;
     533    bundle.OnHold.nCommands = 0;
     534    bundle.OnRelease.nCommands = 0;
    355535  }
    356536
    … …  
    361541  bool KeyBinder::loadBindings()
    362542  {
    363     COUT(ORX_DEBUG) << "KeyBinder: Loading key bindings..." << std::endl;
     543    COUT(3) << "KeyBinder: Loading key bindings..." << std::endl;
     544
     545    // clear half axes
     546    for (unsigned int i = 0; i < nHalfAxes_s; i++)
     547    {
     548      halfAxes_[i].hasChanged = false;
     549      halfAxes_[i].abs = 0.0f;
     550      halfAxes_[i].rel = 0.0f;
     551      halfAxes_[i].wasDown = false;
     552      halfAxes_[i].threshold = 0.01f;
     553    }
    364554
    365555    ConfigFileManager::getSingleton()->setFile(CFT_Keybindings, "keybindings.ini");
     556    clearBindings();
    366557    setConfigValues();
    367558
    368     // evaluate the key bindings
    369     // TODO: what if binding is invalid?
    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     }
    378 
    379     COUT(ORX_DEBUG) << "KeyBinder: Loading key bindings done." << std::endl;
    380     return true;
    381   }
    382 
    383   bool KeyBinder::executeSimpleBinding(KeyBinding& binding)
    384   {
    385     if (binding.commandStr != "")
    386     {
    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;
    394       CommandExecutor::execute(binding.commandStr);
    395     }
    396 
     559    COUT(3) << "KeyBinder: Loading key bindings done." << std::endl;
     560    return true;
     561  }
     562
     563  void KeyBinder::tick(float dt)
     564  {
     565    // we have to process all the analog input since there is e.g. no 'mouseDoesntMove' event.
     566    for (unsigned int i = 0; i < nHalfAxes_s; i++)
     567    {
     568      if (!halfAxes_[i].hasChanged)
     569      {
     570        if (!halfAxes_[i].wasDown && halfAxes_[i].abs > halfAxes_[i].threshold)
     571        {
     572          halfAxes_[i].wasDown = true;
     573          if (bindingsHalfAxes_[i].OnPress.nCommands)
     574            executeBinding(bindingsHalfAxes_[i].OnPress, halfAxes_[i].rel, halfAxes_[i].abs);
     575        }
     576        else if (halfAxes_[i].wasDown && halfAxes_[i].abs < halfAxes_[i].threshold)
     577        {
     578          halfAxes_[i].wasDown = false;
     579          if (bindingsHalfAxes_[i].OnRelease.nCommands)
     580            executeBinding(bindingsHalfAxes_[i].OnRelease, halfAxes_[i].rel, halfAxes_[i].abs);
     581        }
     582        if (halfAxes_[i].wasDown)
     583        {
     584          executeBinding(bindingsHalfAxes_[i].OnHold, halfAxes_[i].rel, halfAxes_[i].abs);
     585        }
     586        halfAxes_[i].hasChanged = false;
     587      }
     588    }
     589
     590    // execute all buffered bindings (addional parameter)
     591    for (unsigned int i = 0; i < axisCommands_.size(); i++)
     592    {
     593      if (axisCommands_[i]->nValuesAdded > 0)
     594      {
     595        axisCommands_[i]->evaluation.setEvaluatedParameter(0, axisCommands_[i]->value);
     596        // reset
     597        axisCommands_[i]->nValuesAdded = 0;
     598        axisCommands_[i]->value = 0.0f;
     599      }
     600    }
     601  }
     602
     603  bool KeyBinder::executeBinding(KeyBinding& binding, float axisRel, float axisAbs)
     604  {
     605    // execute all the parsed commands in the string
     606    for (unsigned int iCommand = 0; iCommand < binding.nCommands; iCommand++)
     607    {
     608      SimpleCommand& command = binding.commands[iCommand];
     609      if (command.axisCommand)
     610      {
     611        AxisCommand& axisCommand = *command.axisCommand;
     612        // command has an additional parameter
     613        if (command.axisCommand->bRelative)
     614        {
     615          // we have to calculate a relative movement.
     616          // amplitude says how much one keystroke is
     617          axisCommand.value += command.axisModifier * axisRel;
     618        }
     619        else
     620        {
     621          // we have to calculate absolute position of the axis.
     622          // for a key this simply is 1, but multiplied by a user defined factor
     623          // since there might be another axis that is affected, we have to wait and
     624          // store the result in a temporary place
     625          axisCommand.value =
     626              (axisCommand.value * (axisCommand.nValuesAdded++) + command.axisModifier * axisAbs)
     627              / axisCommand.nValuesAdded;
     628        }
     629      }
     630      else
     631      {
     632        // simple command, just execute directly
     633        // TODO: calculate whether this a Press, Release or Hold event
     634        CommandExecutor::execute(command.evaluation);
     635      }
     636    }
    397637    return true;
    398638  }
    … …  
    406646  {
    407647    // find the appropriate key binding
    408     executeSimpleBinding(bindingsKeyPress_[int(evt.key)]);
     648    executeBinding(bindingsKeys_[int(evt.key)].OnPress, 1.0, 1.0);
    409649
    410650    return true;
    … …  
    418658  {
    419659    // find the appropriate key binding
    420     executeSimpleBinding(bindingsKeyRelease_[int(evt.key)]);
     660    executeBinding(bindingsKeys_[int(evt.key)].OnRelease, 1.0, 1.0);
    421661
    422662    return true;
    … …  
    430670  {
    431671    // find the appropriate key binding
    432     executeSimpleBinding(bindingsKeyHold_[int(evt.key)]);
     672    executeBinding(bindingsKeys_[int(evt.key)].OnHold, 1.0, 1.0);
    433673
    434674    return true;
    … …  
    439679    @param e Mouse state information
    440680  */
    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     }*/
     681  bool KeyBinder::mouseMoved(IntVector2 abs, IntVector2 rel, IntVector2 clippingSize)
     682  {
     683    halfAxes_[0].hasChanged = true;
     684    halfAxes_[1].hasChanged = true;
     685    halfAxes_[2].hasChanged = true;
     686    halfAxes_[3].hasChanged = true;
     687    // translate absolute mouse position into joystick like behaviour
     688    if (clippingSize.x > clippingSize.y)
     689    {
     690      int margin = (clippingSize.x - clippingSize.y) / 2;
     691      if (abs.x - margin > clippingSize.y)
     692      {
     693        halfAxes_[0].abs = 1.0f;
     694        halfAxes_[1].abs = 0.0f;
     695      }
     696      else if (abs.x < margin)
     697      {
     698        halfAxes_[0].abs = 0.0f;
     699        halfAxes_[1].abs = 1.0f;
     700      }
     701      else
     702      {
     703        float temp = ((float)abs.x) / clippingSize.y * 2 - 1;
     704        if (temp > 0)
     705        {
     706          halfAxes_[0].abs = temp;
     707          halfAxes_[1].abs = 0.0f;
     708        }
     709        else
     710        {
     711          halfAxes_[0].abs = 0.0f;
     712          halfAxes_[1].abs = -temp;
     713        }
     714      }
     715
     716      float temp = -((float)abs.y) / clippingSize.y * 2 + 1;
     717      if (temp > 0)
     718      {
     719        halfAxes_[2].abs = temp;
     720        halfAxes_[3].abs = 0.0;
     721      }
     722      else
     723      {
     724        halfAxes_[2].abs = 0.0;
     725        halfAxes_[3].abs = -temp;
     726      }
     727    }
     728    else
     729    {
     730      float temp = ((float)abs.x) / clippingSize.x * 2 - 1;
     731      if (temp > 0)
     732      {
     733        halfAxes_[0].abs = temp;
     734        halfAxes_[1].abs = 0.0;
     735      }
     736      else
     737      {
     738        halfAxes_[0].abs = 0.0;
     739        halfAxes_[1].abs = -temp;
     740      }
     741
     742      int margin = (clippingSize.y - clippingSize.x) / 2;
     743      if (abs.y - margin > clippingSize.x)
     744      {
     745        halfAxes_[2].abs = 0.0;
     746        halfAxes_[3].abs = 1.0;
     747      }
     748      else if (abs.y < margin)
     749      {
     750        halfAxes_[2].abs = 1.0;
     751        halfAxes_[3].abs = 0.0;
     752      }
     753      else
     754      {
     755        float temp = -((float)abs.y) / clippingSize.x * 2 + 1;
     756        if (temp > 0)
     757        {
     758          halfAxes_[2].abs = temp;
     759          halfAxes_[3].abs = 0.0;
     760        }
     761        else
     762        {
     763          halfAxes_[2].abs = 0.0;
     764          halfAxes_[3].abs = -temp;
     765        }
     766      }
     767    }
     768   
     769    // relative movements
     770    if (rel.x > 0)
     771    {
     772      halfAxes_[0].rel = rel.x;
     773      halfAxes_[1].rel = 0.0;
     774    }
     775    else
     776    {
     777      halfAxes_[0].rel = 0.0;
     778      halfAxes_[1].rel = rel.x;
     779    }
     780
     781    if (rel.y /*!*/ < /*!*/ 0)
     782    {
     783      halfAxes_[0].rel = -rel.y;
     784      halfAxes_[1].rel = 0.0;
     785    }
     786    else
     787    {
     788      halfAxes_[0].rel = 0.0;
     789      halfAxes_[1].rel = -rel.y;
     790    }
    456791
    457792    return true;
    … …  
    462797    @param e Mouse state information
    463798  */
    464   bool KeyBinder::mouseScrolled(const MouseState &evt)
    465   {
     799  bool KeyBinder::mouseScrolled(int abs, int rel)
     800  {
     801    // TODO: obvious...
    466802    return true;
    467803  }
    … …  
    472808    @param id The ID of the mouse button
    473809  */
    474   bool KeyBinder::mouseButtonPressed(const MouseState& state, MouseButton::Enum id)
     810  bool KeyBinder::mouseButtonPressed(MouseButton::Enum id)
    475811  {
    476812    // find the appropriate key binding
    477     executeSimpleBinding(bindingsMouseButtonPress_[int(id)]);
     813    executeBinding(bindingsMouseButtons_[int(id)].OnPress, 1.0, 1.0);
    478814
    479815    return true;
    … …  
    485821    @param id The ID of the mouse button
    486822  */
    487   bool KeyBinder::mouseButtonReleased(const MouseState& state, MouseButton::Enum id)
     823  bool KeyBinder::mouseButtonReleased(MouseButton::Enum id)
    488824  {
    489825    // find the appropriate key binding
    490     executeSimpleBinding(bindingsMouseButtonRelease_[int(id)]);
     826    executeBinding(bindingsMouseButtons_[int(id)].OnRelease, 1.0, 1.0);
    491827
    492828    return true;
    … …  
    498834    @param id The ID of the mouse button
    499835  */
    500   bool KeyBinder::mouseButtonHeld(const MouseState& state, MouseButton::Enum id)
     836  bool KeyBinder::mouseButtonHeld(MouseButton::Enum id)
    501837  {
    502838    // 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)
     839    executeBinding(bindingsMouseButtons_[int(id)].OnHold, 1.0, 1.0);
     840
     841    return true;
     842  }
     843
     844  bool KeyBinder::joyStickButtonPressed(int joyStickID, int button)
    509845  {
    510846    // find the appropriate key binding
    511     executeSimpleBinding(bindingsJoyStickButtonPress_[button]);
    512 
    513     return true;
    514   }
    515 
    516   bool KeyBinder::joyStickButtonReleased(const JoyStickState& state, int button)
     847    executeBinding(bindingsJoyStickButtons_[button].OnPress, 1.0, 1.0);
     848
     849    return true;
     850  }
     851
     852  bool KeyBinder::joyStickButtonReleased(int joyStickID, int button)
    517853  {
    518854    // find the appropriate key binding
    519     executeSimpleBinding(bindingsJoyStickButtonRelease_[button]);
    520 
    521     return true;
    522   }
    523 
    524   bool KeyBinder::joyStickButtonHeld(const JoyStickState& state, int button)
     855    executeBinding(bindingsJoyStickButtons_[button].OnRelease, 1.0, 1.0);
     856
     857    return true;
     858  }
     859
     860  bool KeyBinder::joyStickButtonHeld(int joyStickID, int button)
    525861  {
    526862    // 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)
    548   {
    549     return true;
    550   }
    551 
     863    executeBinding(bindingsJoyStickButtons_[button].OnHold, 1.0, 1.0);
     864
     865    return true;
     866  }
     867
     868  bool KeyBinder::joyStickAxisMoved(int joyStickID, int axis, int value)
     869  {
     870    // TODO: check whether 16 bit integer as general axis value is a good idea (works under windows)
     871    halfAxes_[8 + axis].hasChanged = true;
     872    if (value >= 0)
     873    {
     874      halfAxes_[8 + axis].abs = ((float)value)/0x1000;
     875      halfAxes_[8 + axis].hasChanged = true;
     876    }
     877    else
     878    {
     879      halfAxes_[8 + axis + 1].abs = -((float)value)/0x1000;
     880      halfAxes_[8 + axis + 1].hasChanged = true;
     881    }
     882    return true;
     883  }
    552884
    553885
Note: See TracChangeset for help on using the changeset viewer.