Source/Plugins/Plugin_GCPadNew/Src/ControllerInterface/DirectInput/DirectInputKeyboardMouse.cpp

   1 #include "../ControllerInterface.h"
   2
   3 #ifdef CIFACE_USE_DIRECTINPUT_KBM
   4
   5 #include "DirectInputKeyboardMouse.h"
   6
   7 // TODO: maybe add a ClearInputState function to this device
   8
   9         // (lower would be more sensitive) user can lower sensitivity by setting range
  10         // seems decent here ( at 8 ), I dont think anyone would need more sensitive than this
  11         // and user can lower it much farther than they would want to with the range
  12 #define MOUSE_AXIS_SENSITIVITY          8
  13
  14         // if input hasn't been received for this many ms, mouse input will be skipped
  15         // otherwise it is just some crazy value
  16 #define DROP_INPUT_TIME                         250
  17
  18 namespace ciface
  19 {
  20 namespace DirectInput
  21 {
  22
  23 struct
  24 {
  25         const BYTE                      code;
  26         const char* const       name;
  27 } named_keys[] =
  28 {
  29 #include "NamedKeys.h"
  30 };
  31
  32 struct
  33 {
  34         const BYTE                      code;
  35         const char* const       name;
  36 } named_lights[] =
  37 {
  38         { VK_NUMLOCK, "NUM LOCK" },
  39         { VK_CAPITAL, "CAPS LOCK" },
  40         { VK_SCROLL, "SCROLL LOCK" }
  41 };
  42
  43 void InitKeyboardMouse( IDirectInput8* const idi8, std::vector<ControllerInterface::Device*>& devices )
  44 {
  45         // mouse and keyboard are a combined device, to allow shift+click and stuff
  46         // if thats dumb, i will make a VirtualDevice class that just uses ranges of inputs/outputs from other devices
  47         // so there can be a separated Keyboard and mouse, as well as combined KeyboardMouse
  48
  49         // TODO: this has potential to not release devices if set datafmt or cooplevel fails
  50
  51         LPDIRECTINPUTDEVICE8 kb_device;
  52         LPDIRECTINPUTDEVICE8 mo_device;
  53
  54         if ( DI_OK == idi8->CreateDevice( GUID_SysKeyboard, &kb_device, NULL ) )
  55         if ( DI_OK == kb_device->SetDataFormat( &c_dfDIKeyboard ) )
  56         if ( DI_OK == kb_device->SetCooperativeLevel( NULL, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE) )
  57         if ( DI_OK == kb_device->Acquire() )
  58         {
  59
  60                 if ( DI_OK == idi8->CreateDevice( GUID_SysMouse, &mo_device, NULL ) )
  61                 if ( DI_OK == mo_device->SetDataFormat( &c_dfDIMouse2 ) )
  62                 if ( DI_OK == mo_device->SetCooperativeLevel( NULL, DISCL_BACKGROUND | DISCL_NONEXCLUSIVE) )
  63                 if ( DI_OK == mo_device->Acquire() )
  64                 {
  65                         devices.push_back( new KeyboardMouse( kb_device, mo_device ) );
  66                         return;
  67                 }
  68                 else
  69                         goto release_mouse;
  70
  71                 goto unacquire_kb;
  72         }
  73         else
  74                 goto release_kb;
  75
  76 release_mouse:
  77         mo_device->Release();
  78 unacquire_kb:
  79         kb_device->Unacquire();
  80 release_kb:
  81         kb_device->Release();
  82 }
  83
  84 KeyboardMouse::~KeyboardMouse()
  85 {
  86         // kb
  87         m_kb_device->Unacquire();
  88         m_kb_device->Release();
  89         // mouse
  90         m_mo_device->Unacquire();
  91         m_mo_device->Release();
  92 }
  93
  94 KeyboardMouse::KeyboardMouse( const LPDIRECTINPUTDEVICE8 kb_device, const LPDIRECTINPUTDEVICE8 mo_device )
  95         : m_kb_device(kb_device)
  96         , m_mo_device(mo_device)
  97 {
  98         m_last_update = wxGetLocalTimeMillis();
  99
 100         ZeroMemory( &m_state_in, sizeof(m_state_in) );
 101         ZeroMemory( m_state_out, sizeof(m_state_out) );
 102         ZeroMemory( &m_current_state_out, sizeof(m_current_state_out) );
 103
 104         // KEYBOARD
 105         // add keys
 106         for ( unsigned int i = 0; i < sizeof(named_keys)/sizeof(*named_keys); ++i )
 107                 inputs.push_back( new Key( i ) );
 108         // add lights
 109         for ( unsigned int i = 0; i < sizeof(named_lights)/sizeof(*named_lights); ++i )
 110                 outputs.push_back( new Light( i ) );
 111
 112         // MOUSE
 113         // get caps
 114         DIDEVCAPS mouse_caps;
 115         ZeroMemory( &mouse_caps, sizeof(mouse_caps) );
 116         mouse_caps.dwSize = sizeof(mouse_caps);
 117         m_mo_device->GetCapabilities(&mouse_caps);
 118         // mouse buttons
 119         for ( unsigned int i = 0; i < mouse_caps.dwButtons; ++i )
 120                 inputs.push_back( new Button( i ) );
 121         // mouse axes
 122         for ( unsigned int i = 0; i < mouse_caps.dwAxes; ++i )
 123         {
 124                 // each axis gets a negative and a positive input instance associated with it
 125                 inputs.push_back( new Axis( i, (2==i) ? -1 : -MOUSE_AXIS_SENSITIVITY ) );
 126                 inputs.push_back( new Axis( i, -(2==i) ? 1 : MOUSE_AXIS_SENSITIVITY ) );
 127         }
 128
 129 }
 130
 131 bool KeyboardMouse::UpdateInput()
 132 {
 133         DIMOUSESTATE2 tmp_mouse;
 134
 135         // if mouse position hasn't been updated in a short while, skip a dev state
 136         wxLongLong cur_time = wxGetLocalTimeMillis();
 137         if ( cur_time - m_last_update > DROP_INPUT_TIME )
 138         {
 139                 // set axes to zero
 140                 ZeroMemory( &m_state_in.mouse, sizeof(m_state_in.mouse) );
 141                 // skip this input state
 142                 m_mo_device->GetDeviceState( sizeof(tmp_mouse), &tmp_mouse );
 143         }
 144
 145         m_last_update = cur_time;
 146
 147         if ( DI_OK == m_kb_device->GetDeviceState( sizeof(m_state_in.keyboard), &m_state_in.keyboard )
 148                 && DI_OK == m_mo_device->GetDeviceState( sizeof(tmp_mouse), &tmp_mouse ) )
 149         {
 150                 // need to smooth out the axes, otherwise it doesnt work for shit
 151                 for ( unsigned int i = 0; i < 3; ++i )
 152                         ((&m_state_in.mouse.lX)[i] += (&tmp_mouse.lX)[i]) /= 2;
 153
 154                 // copy over the buttons
 155                 memcpy( m_state_in.mouse.rgbButtons, tmp_mouse.rgbButtons, sizeof(m_state_in.mouse.rgbButtons) );
 156                 return true;
 157         }
 158         else
 159                 return false;
 160 }
 161
 162 bool KeyboardMouse::UpdateOutput()
 163 {
 164         class KInput : public INPUT
 165         {
 166         public:
 167                 KInput( const unsigned char key, const bool up = false )
 168                 {
 169                         memset( this, 0, sizeof(*this) );
 170                         type = INPUT_KEYBOARD;
 171                         ki.wVk = key;
 172                         if (up) ki.dwFlags = KEYEVENTF_KEYUP;
 173                 }
 174         };
 175
 176         std::vector< KInput > kbinputs;
 177         for ( unsigned int i = 0; i < sizeof(m_state_out)/sizeof(*m_state_out); ++i )
 178         {
 179                 bool want_on = false;
 180                 if ( m_state_out[i] )
 181                         want_on = m_state_out[i] > wxGetLocalTimeMillis() % 255 ;       // light should flash when output is 0.5
 182
 183                 // lights are set to their original state when output is zero
 184                 if ( want_on ^ m_current_state_out[i] )
 185                 {
 186                         kbinputs.push_back( KInput( named_lights[i].code ) );           // press
 187                         kbinputs.push_back( KInput( named_lights[i].code, true ) ); // release
 188
 189                         m_current_state_out[i] ^= 1;
 190                 }
 191         }
 192
 193         if ( kbinputs.size() )
 194                 return ( kbinputs.size() == SendInput( (UINT)kbinputs.size(), &kbinputs[0], sizeof( kbinputs[0] ) ) );
 195         else
 196                 return true;
 197 }
 198
 199 std::string KeyboardMouse::GetName() const
 200 {
 201         return "Keyboard Mouse";
 202 }
 203
 204 int KeyboardMouse::GetId() const
 205 {
 206         // should this be -1, idk
 207         return 0;
 208 }
 209
 210 std::string KeyboardMouse::GetSource() const
 211 {
 212         return "DirectInput";
 213 }
 214
 215 ControlState KeyboardMouse::GetInputState( const ControllerInterface::Device::Input* const input )
 216 {
 217         return ( ((Input*)input)->GetState( &m_state_in ) );
 218 }
 219
 220 void KeyboardMouse::SetOutputState( const ControllerInterface::Device::Output* const output, const ControlState state )
 221 {
 222         ((Output*)output)->SetState( state, m_state_out );
 223 }
 224
 225 // names
 226 std::string KeyboardMouse::Key::GetName() const
 227 {
 228         return named_keys[m_index].name;
 229 }
 230
 231 std::string KeyboardMouse::Button::GetName() const
 232 {
 233         return std::string("Button ") + char('0'+m_index);
 234 }
 235
 236 std::string KeyboardMouse::Axis::GetName() const
 237 {
 238         std::string tmpstr("Mouse ");
 239         tmpstr += "XYZ"[m_index]; tmpstr += ( m_range>0 ? '+' : '-' );
 240         return tmpstr;
 241 }
 242
 243 std::string KeyboardMouse::Light::GetName() const
 244 {
 245         return named_lights[ m_index ].name;
 246 }
 247
 248 // get/set state
 249 ControlState KeyboardMouse::Key::GetState( const State* const state )
 250 {
 251         return ( state->keyboard[named_keys[m_index].code] > 0 );
 252 }
 253
 254 ControlState KeyboardMouse::Button::GetState( const State* const state )
 255 {
 256         return ( state->mouse.rgbButtons[m_index] > 0 );
 257 }
 258
 259 ControlState KeyboardMouse::Axis::GetState( const State* const state )
 260 {
 261         return std::max( 0.0f, ControlState((&state->mouse.lX)[m_index]) / m_range );
 262 }
 263
 264 void KeyboardMouse::Light::SetState( const ControlState state, unsigned char* const state_out )
 265 {
 266         state_out[ m_index ] = state * 255;
 267 }
 268
 269 }
 270 }
 271
 272 #endif