src/Input/FGJoystickInput.cxx

   1 // FGJoystickInput.cxx -- handle user input from joystick devices
   2 //
   3 // Written by Torsten Dreyer, started August 2009
   4 // Based on work from David Megginson, started May 2001.
   5 //
   6 // Copyright (C) 2009 Torsten Dreyer, Torsten (at) t3r _dot_ de
   7 // Copyright (C) 2001 David Megginson, david@megginson.com
   8 //
   9 // This program is free software; you can redistribute it and/or
  10 // modify it under the terms of the GNU General Public License as
  11 // published by the Free Software Foundation; either version 2 of the
  12 // License, or (at your option) any later version.
  13 //
  14 // This program is distributed in the hope that it will be useful, but
  15 // WITHOUT ANY WARRANTY; without even the implied warranty of
  16 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17 // General Public License for more details.
  18 //
  19 // You should have received a copy of the GNU General Public License
  20 // along with this program; if not, write to the Free Software
  21 // Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  22 //
  23 // $Id$
  24
  25 #include "FGJoystickInput.hxx"
  26 #include "FGDeviceConfigurationMap.hxx"
  27 #include <Main/fg_props.hxx>
  28 #include <Scripting/NasalSys.hxx>
  29
  30 using simgear::PropertyList;
  31
  32 FGJoystickInput::axis::axis ()
  33   : last_value(9999999),
  34     tolerance(0.002),
  35     low_threshold(-0.9),
  36     high_threshold(0.9),
  37     interval_sec(0),
  38     last_dt(0)
  39 {
  40 }
  41
  42 FGJoystickInput::axis::~axis ()
  43 {
  44 }
  45
  46 FGJoystickInput::joystick::joystick ()
  47   : jsnum(0),
  48     js(0),
  49     naxes(0),
  50     nbuttons(0),
  51     axes(0),
  52     buttons(0)
  53 {
  54 }
  55
  56 FGJoystickInput::joystick::~joystick ()
  57 {
  58   //  delete js? no, since js == this - and we're in the destructor already.
  59   delete[] axes;
  60   delete[] buttons;
  61   jsnum = 0;
  62   js = NULL;
  63   naxes = 0;
  64   nbuttons = 0;
  65   axes = NULL;
  66   buttons = NULL;
  67 }
  68
  69
  70 FGJoystickInput::FGJoystickInput()
  71 {
  72 }
  73
  74 FGJoystickInput::~FGJoystickInput()
  75 {
  76     _remove();
  77 }
  78
  79 void FGJoystickInput::_remove()
  80 {
  81     SGPropertyNode * js_nodes = fgGetNode("/input/joysticks", true);
  82     js_nodes->removeChildren("js", false);
  83     for (int i = 0; i < MAX_JOYSTICKS; i++)
  84     {
  85         if (bindings[i].js)
  86             delete bindings[i].js;
  87         bindings[i].js = NULL;
  88     }
  89 }
  90
  91 void FGJoystickInput::init()
  92 {
  93   jsInit();
  94   SG_LOG(SG_INPUT, SG_DEBUG, "Initializing joystick bindings");
  95   SGPropertyNode * js_nodes = fgGetNode("/input/joysticks", true);
  96
  97   FGDeviceConfigurationMap configMap("Input/Joysticks", js_nodes, "js-named");
  98
  99   for (int i = 0; i < MAX_JOYSTICKS; i++) {
 100     jsJoystick * js = new jsJoystick(i);
 101     bindings[i].js = js;
 102
 103     if (js->notWorking()) {
 104       SG_LOG(SG_INPUT, SG_DEBUG, "Joystick " << i << " not found");
 105       continue;
 106     }
 107
 108     const char * name = js->getName();
 109     SGPropertyNode_ptr js_node = js_nodes->getChild("js", i);
 110
 111     if (js_node) {
 112       SG_LOG(SG_INPUT, SG_INFO, "Using existing bindings for joystick " << i);
 113
 114     } else {
 115       SG_LOG(SG_INPUT, SG_INFO, "Looking for bindings for joystick \"" << name << '"');
 116       SGPropertyNode_ptr named;
 117
 118       if ((named = configMap[name])) {
 119         string source = named->getStringValue("source", "user defined");
 120         SG_LOG(SG_INPUT, SG_INFO, "... found joystick: " << source);
 121
 122       } else if ((named = configMap["default"])) {
 123         string source = named->getStringValue("source", "user defined");
 124         SG_LOG(SG_INPUT, SG_INFO, "No config found for joystick \"" << name
 125             << "\"\nUsing default: \"" << source << '"');
 126
 127       } else {
 128         SG_LOG(SG_INPUT, SG_WARN, "No joystick configuration file with <name>" << name << "</name> entry found!");
 129       }
 130
 131       js_node = js_nodes->getChild("js", i, true);
 132       copyProperties(named, js_node);
 133       js_node->setStringValue("id", name);
 134     }
 135   }
 136 }
 137
 138 void FGJoystickInput::reinit() {
 139   SG_LOG(SG_INPUT, SG_DEBUG, "Re-Initializing joystick bindings");
 140   _remove();
 141   FGJoystickInput::init();
 142   FGJoystickInput::postinit();
 143 }
 144
 145 void FGJoystickInput::postinit()
 146 {
 147   FGNasalSys *nasalsys = (FGNasalSys *)globals->get_subsystem("nasal");
 148   SGPropertyNode_ptr js_nodes = fgGetNode("/input/joysticks");
 149
 150   for (int i = 0; i < MAX_JOYSTICKS; i++) {
 151     SGPropertyNode_ptr js_node = js_nodes->getChild("js", i);
 152     jsJoystick *js = bindings[i].js;
 153     if (!js_node || js->notWorking())
 154       continue;
 155
 156 #ifdef WIN32
 157     JOYCAPS jsCaps ;
 158     joyGetDevCaps( i, &jsCaps, sizeof(jsCaps) );
 159     unsigned int nbuttons = jsCaps.wNumButtons;
 160     if (nbuttons > MAX_JOYSTICK_BUTTONS) nbuttons = MAX_JOYSTICK_BUTTONS;
 161 #else
 162     unsigned int nbuttons = MAX_JOYSTICK_BUTTONS;
 163 #endif
 164
 165     int naxes = js->getNumAxes();
 166     if (naxes > MAX_JOYSTICK_AXES) naxes = MAX_JOYSTICK_AXES;
 167     bindings[i].naxes = naxes;
 168     bindings[i].nbuttons = nbuttons;
 169
 170     SG_LOG(SG_INPUT, SG_DEBUG, "Initializing joystick " << i);
 171
 172                                 // Set up range arrays
 173     float minRange[MAX_JOYSTICK_AXES];
 174     float maxRange[MAX_JOYSTICK_AXES];
 175     float center[MAX_JOYSTICK_AXES];
 176
 177                                 // Initialize with default values
 178     js->getMinRange(minRange);
 179     js->getMaxRange(maxRange);
 180     js->getCenter(center);
 181
 182                                 // Allocate axes and buttons
 183     bindings[i].axes = new axis[naxes];
 184     bindings[i].buttons = new FGButton[nbuttons];
 185
 186     //
 187     // Initialize nasal groups.
 188     //
 189     ostringstream str;
 190     str << "__js" << i;
 191     string module = str.str();
 192     nasalsys->createModule(module.c_str(), module.c_str(), "", 0);
 193
 194     PropertyList nasal = js_node->getChildren("nasal");
 195     unsigned int j;
 196     for (j = 0; j < nasal.size(); j++) {
 197       nasal[j]->setStringValue("module", module.c_str());
 198       nasalsys->handleCommand(nasal[j]);
 199     }
 200
 201     //
 202     // Initialize the axes.
 203     //
 204     PropertyList axes = js_node->getChildren("axis");
 205     size_t nb_axes = axes.size();
 206     for (j = 0; j < nb_axes; j++ ) {
 207       const SGPropertyNode * axis_node = axes[j];
 208       const SGPropertyNode * num_node = axis_node->getChild("number");
 209       int n_axis = axis_node->getIndex();
 210       if (num_node != 0) {
 211           n_axis = num_node->getIntValue(TGT_PLATFORM, -1);
 212
 213           // Silently ignore platforms that are not specified within the
 214           // <number></number> section
 215           if (n_axis < 0)
 216              continue;
 217       }
 218
 219       if (n_axis >= naxes) {
 220           SG_LOG(SG_INPUT, SG_DEBUG, "Dropping bindings for axis " << n_axis);
 221           continue;
 222       }
 223       axis &a = bindings[i].axes[n_axis];
 224
 225       js->setDeadBand(n_axis, axis_node->getDoubleValue("dead-band", 0.0));
 226
 227       a.tolerance = axis_node->getDoubleValue("tolerance", 0.002);
 228       minRange[n_axis] = axis_node->getDoubleValue("min-range", minRange[n_axis]);
 229       maxRange[n_axis] = axis_node->getDoubleValue("max-range", maxRange[n_axis]);
 230       center[n_axis] = axis_node->getDoubleValue("center", center[n_axis]);
 231
 232       read_bindings(axis_node, a.bindings, KEYMOD_NONE, module );
 233
 234       // Initialize the virtual axis buttons.
 235       a.low.init(axis_node->getChild("low"), "low", module );
 236       a.low_threshold = axis_node->getDoubleValue("low-threshold", -0.9);
 237
 238       a.high.init(axis_node->getChild("high"), "high", module );
 239       a.high_threshold = axis_node->getDoubleValue("high-threshold", 0.9);
 240       a.interval_sec = axis_node->getDoubleValue("interval-sec",0.0);
 241       a.last_dt = 0.0;
 242     }
 243
 244     //
 245     // Initialize the buttons.
 246     //
 247     PropertyList buttons = js_node->getChildren("button");
 248     char buf[32];
 249     for (j = 0; j < buttons.size() && j < nbuttons; j++) {
 250       const SGPropertyNode * button_node = buttons[j];
 251       const SGPropertyNode * num_node = button_node->getChild("number");
 252       size_t n_but = button_node->getIndex();
 253       if (num_node != 0) {
 254           n_but = num_node->getIntValue(TGT_PLATFORM,n_but);
 255       }
 256
 257       if (n_but >= nbuttons) {
 258           SG_LOG(SG_INPUT, SG_DEBUG, "Dropping bindings for button " << n_but);
 259           continue;
 260       }
 261
 262       sprintf(buf, "%u", (unsigned)n_but);
 263       SG_LOG(SG_INPUT, SG_DEBUG, "Initializing button " << n_but);
 264       bindings[i].buttons[n_but].init(button_node, buf, module );
 265
 266       // get interval-sec property
 267       FGButton &b = bindings[i].buttons[n_but];
 268       if (button_node != 0) {
 269         b.interval_sec = button_node->getDoubleValue("interval-sec",0.0);
 270         b.last_dt = 0.0;
 271       }
 272     }
 273
 274     js->setMinRange(minRange);
 275     js->setMaxRange(maxRange);
 276     js->setCenter(center);
 277   }
 278 }
 279
 280 void FGJoystickInput::update( double dt )
 281 {
 282   float axis_values[MAX_JOYSTICK_AXES];
 283   int modifiers = fgGetKeyModifiers();
 284   int buttons;
 285
 286   for (int i = 0; i < MAX_JOYSTICKS; i++) {
 287
 288     jsJoystick * js = bindings[i].js;
 289     if (js == 0 || js->notWorking())
 290       continue;
 291
 292     js->read(&buttons, axis_values);
 293     if (js->notWorking()) // If js is disconnected
 294       continue;
 295
 296                                 // Fire bindings for the axes.
 297     for (int j = 0; j < bindings[i].naxes; j++) {
 298       axis &a = bindings[i].axes[j];
 299
 300                                 // Do nothing if the axis position
 301                                 // is unchanged; only a change in
 302                                 // position fires the bindings.
 303       if (fabs(axis_values[j] - a.last_value) > a.tolerance) {
 304         a.last_value = axis_values[j];
 305         for (unsigned int k = 0; k < a.bindings[KEYMOD_NONE].size(); k++)
 306           a.bindings[KEYMOD_NONE][k]->fire(axis_values[j]);
 307       }
 308
 309                                 // do we have to emulate axis buttons?
 310       a.last_dt += dt;
 311       if(a.last_dt >= a.interval_sec) {
 312         if (a.low.bindings[modifiers].size())
 313           bindings[i].axes[j].low.update( modifiers, axis_values[j] < a.low_threshold );
 314
 315         if (a.high.bindings[modifiers].size())
 316           bindings[i].axes[j].high.update( modifiers, axis_values[j] > a.high_threshold );
 317
 318         a.last_dt -= a.interval_sec;
 319       }
 320     }
 321
 322                                 // Fire bindings for the buttons.
 323     for (int j = 0; j < bindings[i].nbuttons; j++) {
 324       FGButton &b = bindings[i].buttons[j];
 325       b.last_dt += dt;
 326       if(b.last_dt >= b.interval_sec) {
 327         bindings[i].buttons[j].update( modifiers, (buttons & (1 << j)) > 0 );
 328         b.last_dt -= b.interval_sec;
 329       }
 330     }
 331   }
 332 }
 333