Joypad.cpp

Go to the documentation of this file.

#include "Joypad.h"
 
extern int JOYPAD_DATA_CB;
 
#ifdef _WIN32
#include <Oleauto.h>
 
boost::mutex gMutex;
 
std::set<GUID> lJoyId;
LPDIRECTINPUT8 DIinterf;
 
Joypad::Joypad(int index)
{
  mIsXInput = false;
  pJoystick = NULL;
  mTick = NULL;
  mConnected = false;
  mControllerId = -1;
  mIndex = index;
 
  mRumbleEffect = nullptr;
 
  //XInput
  ZeroMemory(&mRumbleState, sizeof(XINPUT_VIBRATION));
  ZeroMemory(&mDIJoyState, sizeof(DIJOYSTATE2));
 
  // Run thread
  mIsrunning = true;
  mThread = boost::thread(boost::bind(&Joypad::run, this));
}
 
Joypad::~Joypad(void)
{
  mIsrunning = false;
  mThread.join();
}
 
void Joypad::run()
{
  try
  {
    // get new data 30 time a second
    while (mIsrunning)
    {
      boost::mutex::scoped_lock l(mMutex);
      mTick = GetTickCount();
 
      if (mIsrunning && !mConnected)
        boost::this_thread::sleep_for(boost::chrono::milliseconds(200));
 
      if (mIsrunning && !mConnected && SUCCEEDED(InitDirectInput()))
        mConnected = true;
 
      if (mConnected)
        if (UpdateInputState() != S_OK)
          mConnected = false;
 
      if (!mConnected)
        FreeDirectInput();
 
      int elapsedTime = 33 - (int)(GetTickCount() - mTick);
      if (elapsedTime > 0)
        boost::this_thread::sleep_for(boost::chrono::milliseconds(elapsedTime));
    }
    FreeDirectInput();
  }
  catch (std::exception ex)
  {
    MMechostr(MSKDEBUG, "Joypad > error thread : %s \n", ex.what());
  }
}
 
bool Joypad::IsConnected()
{
  boost::mutex::scoped_lock l(mMutex);
  return mConnected;
}
 
bool Joypad::IsRunning()
{
  boost::mutex::scoped_lock l(mMutex);
  return mIsrunning;
}
 
bool Joypad::StartRumble(float intensity)
{
  StopRumble();
 
  if (mIsXInput)
  {
    mRumbleState.wLeftMotorSpeed = static_cast<WORD>(intensity * 65535.0f);
    mRumbleState.wRightMotorSpeed = static_cast<WORD>(intensity * 65535.0f);
 
    XInputSetState(mControllerId, &mRumbleState);
  }
  else if (pJoystick)
  {
    DIEFFECT effect = {};
    effect.dwSize = sizeof(DIEFFECT);
    effect.dwDuration = INFINITE;
    effect.dwGain = DWORD(10000.0f * intensity);
    effect.dwFlags = DIEFF_CARTESIAN | DIEFF_OBJECTOFFSETS;
    effect.cAxes = 2;
    effect.rgdwAxes = new DWORD[2];
    effect.rgdwAxes[0] = DIJOFS_X;
    effect.rgdwAxes[1] = DIJOFS_Y;
    effect.rglDirection = new LONG[2];
    effect.rglDirection[0] = -200;
    effect.rglDirection[1] = 200;
 
    HRESULT hr = pJoystick->CreateEffect(GUID_Sine, &effect, &mRumbleEffect, nullptr);
    if (FAILED(hr))
    {
      // Handle error
      return false;
    }
 
    // Start the rumble effect
    hr = mRumbleEffect->Start(1, 0);
    if (FAILED(hr))
    {
      mRumbleEffect->Release(); // Release the effect
      mRumbleEffect = nullptr;
      // Handle error
      return false;
    }
  }
  else
    return false;
 
  return true;
}
 
 
void Joypad::StopRumble()
{
  if (mIsXInput)
  {
    ZeroMemory(&mRumbleState, sizeof(XINPUT_VIBRATION));
    XInputSetState(mControllerId, &mRumbleState);
  }
  else
  {
    if (mRumbleEffect)
    {
      HRESULT hr = mRumbleEffect->Stop();
      if (FAILED(hr))
      {
        // Handle error
        return;
      }
 
      mRumbleEffect->Release(); // Release the effect
      mRumbleEffect = nullptr;
    }
  }
}
 
//-----------------------------------------------------------------------------
// Name: FreeDirectInput()
// Desc: Initialize the DirectInput variables.
//-----------------------------------------------------------------------------
VOID Joypad::FreeDirectInput()
{
  boost::mutex::scoped_lock l(gMutex);
 
  StopRumble();
 
  // Unacquire the device one last time just in case
  // the app tried to exit while the device is still acquired.
  if (pJoystick)
    pJoystick->Unacquire();
 
  // Release any DirectInput objects.
  SAFE_RELEASE(pJoystick);
 
  std::set<GUID>::iterator iJoystickIdSearched = lJoyId.find(mInstanceId);
  if (iJoystickIdSearched != lJoyId.end())
    lJoyId.erase(iJoystickIdSearched);
 
  if (lJoyId.empty())
    SAFE_RELEASE(DIinterf);
}
 
 
//-----------------------------------------------------------------------------
// Name: InitDirectInput()
// Desc: Initialize the DirectInput variables.
//-----------------------------------------------------------------------------
HRESULT Joypad::InitDirectInput()
{
  boost::mutex::scoped_lock l(gMutex);
  HRESULT hr;
 
  // Register with the DirectInput subsystem and get a pointer
  // to a IDirectInput interface we can use.
  // Create a DInput object
 
  if (DIinterf == NULL)
  {
    if (FAILED(hr = DirectInput8Create(GetModuleHandle(NULL), DIRECTINPUT_VERSION,
      IID_IDirectInput8, (VOID**)&DIinterf, NULL)))
      return hr;
  }
 
  DIJOYCONFIG PreferredJoyCfg;
  ZeroMemory((void*)&PreferredJoyCfg, sizeof(DIJOYCONFIG));
  PreferredJoyCfg.dwSize = sizeof(DIJOYCONFIG) + 1;
 
  pEnumContext.pPreferredJoyCfg = &PreferredJoyCfg;
  pEnumContext.bPreferredJoyCfgValid = false;
 
  IDirectInputJoyConfig8* pJoyConfig = NULL;
  if (FAILED(hr = DIinterf->QueryInterface(IID_IDirectInputJoyConfig8, (void**)&pJoyConfig)))
    return hr;
 
  if (SUCCEEDED(pJoyConfig->GetConfig(0, &PreferredJoyCfg, DIJC_GUIDINSTANCE))) // This function is expected to fail if no joystick is attached
    pEnumContext.bPreferredJoyCfgValid = true;
  SAFE_RELEASE(pJoyConfig);
 
  if (DIinterf == NULL)
    return -1;
 
  mControllerId = -1;
 
  // Look for a simple joystick we can use for this sample program.
  if (FAILED(hr = DIinterf->EnumDevices(DI8DEVCLASS_GAMECTRL, EnumJoysticksCallback, this, DIEDFL_ATTACHEDONLY)))
    return hr;
 
  // Make sure we got a joystick
  if (NULL == pJoystick)
  {
    //MMechostr(MSKDEBUG, "Joystick not found.\n");
    return -1;
  }
 
  // Set the data format to "simple joystick" - a predefined data format
  //
  // A data format specifies which controls on a device we are interested in,
  // and how they should be reported. This tells DInput that we will be
  // passing a DIJOYSTATE2 structure to IDirectInputDevice::GetDeviceState().
  if (FAILED(hr = pJoystick->SetDataFormat(&c_dfDIJoystick2)))
    return hr;
 
  // Set the cooperative level to let DInput know how this device should
  // interact with the system and with other DInput applications.
  if (FAILED(hr = pJoystick->SetCooperativeLevel((HWND)SCgetExtra("hscol"), DISCL_EXCLUSIVE | DISCL_BACKGROUND)))
    return hr;
 
  // Enumerate the joystick objects. The callback function enabled user
  // interface elements for objects that are found, and sets the min/max
  // values property for discovered axes.
  if (FAILED(hr = pJoystick->EnumObjects(EnumObjectsCallback, (VOID*)this, DIDFT_ALL)))
    return hr;
 
  //MMechostr(MSKDEBUG,"Joypad > InitDirectInput OK\n");
  return S_OK;
}
 
 
//-----------------------------------------------------------------------------
// Name: UpdateInputState()
// Desc: Get the input device's state and display it.
//-----------------------------------------------------------------------------
HRESULT Joypad::UpdateInputState()
{
  HRESULT hr = S_OK;
 
  if (NULL == pJoystick)
    return S_FALSE;
 
  // Poll the device to read the current state
  hr = pJoystick->Poll();
  if (FAILED(hr) && (DIinterf != NULL))
  {
    // DInput is telling us that the input stream has been
    // interrupted. We aren't tracking any state between polls, so
    // we don't have any special reset that needs to be done. We
    // just re-acquire and try again.
    hr = pJoystick->Acquire();
    if (hr != DI_OK)
      return S_FALSE;
  }
 
  // Get the input's device state
  if ((pJoystick->GetDeviceState(sizeof(DIJOYSTATE2), &mDIJoyState)) != DI_OK)
    return S_FALSE; // The device should have been acquired during the Poll()
 
  DIJOYSTATE2* ndata = new DIJOYSTATE2;
  *ndata = mDIJoyState;
 
  // manage thrustmaster
  /*
  if (!mIsXInput)
  {
    if (ndata->lRz != 0.0 && ndata->lRx == 0.0)
      ndata->lRx = ndata->lRz;
    if (ndata->rglSlider[0] != 0.0 && ndata->lRy == 0.0)
      ndata->lRy = ndata->rglSlider[0];
  }*/
 
  OBJpostEvent(JOYPAD_DATA_CB, SCOL_PTR this, SCOL_PTR ndata);
  return S_OK;
}
 
//-----------------------------------------------------------------------------
// Name: EnumJoysticksCallback()
// Desc: Called once for each enumerated joystick. If we find one, create a
//       device interface on it so we can play with it.
//-----------------------------------------------------------------------------
BOOL CALLBACK EnumJoysticksCallback(const DIDEVICEINSTANCE* pdidInstance,
  VOID* pContext)
{
  Joypad* joypad = (Joypad*)pContext;
  if (joypad == 0)
    return DIENUM_STOP;
 
  HRESULT hr;
 
  joypad->mControllerId++;
 
  if (joypad->mIndex != 0 && ((joypad->mIndex - 1) != joypad->mControllerId))
    return DIENUM_CONTINUE;
 
  //MMechostr(MSKDEBUG, "EnumJoysticksCallback start %s : %i\n", pdidInstance->tszInstanceName, pdidInstance->guidInstance);
 
  //use only gamepad if not already used by another isntance
  std::set<GUID>::iterator iJoystickIdSearched = lJoyId.find(pdidInstance->guidInstance);
  if (iJoystickIdSearched != lJoyId.end())
    return DIENUM_CONTINUE;
 
  if (DIinterf == NULL)
    return DIENUM_STOP;
 
  // Obtain an interface to the enumerated joystick.
  hr = DIinterf->CreateDevice(pdidInstance->guidInstance, &joypad->pJoystick, NULL);
 
  // If it failed, then we can't use this joystick. (Maybe the user unplugged
  // it while we were in the middle of enumerating it.)
  if (FAILED(hr))
    return DIENUM_CONTINUE;
 
  DIPROPDWORD dipdw;  // DIPROPDWORD contains a DIPROPHEADER structure.
  dipdw.diph.dwSize = sizeof(DIPROPDWORD);
  dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
  dipdw.diph.dwObj = 0; // device property
  dipdw.diph.dwHow = DIPH_DEVICE;
 
  hr = joypad->pJoystick->GetProperty(DIPROP_VIDPID, &dipdw.diph);
  if (FAILED(hr))
  {
    SAFE_RELEASE(joypad->pJoystick);
    joypad->pJoystick = NULL;
    return DIENUM_CONTINUE;
  }
 
  DWORD vendorID = LOWORD(dipdw.dwData);
  DWORD productID = HIWORD(dipdw.dwData);
 
  // Ignore Nintendo devices
  if (vendorID == 0x057e)
  {
    SAFE_RELEASE(joypad->pJoystick);
    joypad->pJoystick = NULL;
    return DIENUM_CONTINUE;
  }
 
  lJoyId.insert(pdidInstance->guidInstance);
  joypad->mInstanceId = pdidInstance->guidInstance;
 
  XINPUT_STATE xInputState;
  joypad->mIsXInput = XInputGetState(joypad->mControllerId, &xInputState) == ERROR_SUCCESS;
 
  //MMechostr(MSKDEBUG, "EnumJoysticksCallback end %s : %i\n", pdidInstance->tszInstanceName, pdidInstance->guidInstance);
 
  // Stop enumeration. Note: we're just taking the first joystick we get.
  return DIENUM_STOP;
}
 
 
//-----------------------------------------------------------------------------
// Name: EnumObjectsCallback()
// Desc: Callback function for enumerating objects (axes, buttons, POVs) on a
//       joystick. This function enables user interface elements for objects
//       that are found to exist, and scales axes min/max values.
//-----------------------------------------------------------------------------
BOOL CALLBACK EnumObjectsCallback(const DIDEVICEOBJECTINSTANCE* pdidoi,
  VOID* pContext)
{
  Joypad * joypad = (Joypad *)pContext;
 
  static int nSliderCount = 0;  // Number of returned slider controls
  static int nPOVCount = 0;     // Number of returned POV controls
 
  // For axes that are returned, set the DIPROP_RANGE property for the
  // enumerated axis in order to scale min/max values.
  if (pdidoi->dwType & DIDFT_AXIS)
  {
    DIPROPRANGE diprg;
    diprg.diph.dwSize = sizeof(DIPROPRANGE);
    diprg.diph.dwHeaderSize = sizeof(DIPROPHEADER);
    diprg.diph.dwHow = DIPH_BYID;
    diprg.diph.dwObj = pdidoi->dwType; // Specify the enumerated axis
    diprg.lMin = -1000;
    diprg.lMax = +1000;
 
    // Set the range for the axis
    if (FAILED(joypad->pJoystick->SetProperty(DIPROP_RANGE, &diprg.diph)))
      return DIENUM_STOP;
  }
 
  return DIENUM_CONTINUE;
}
 
#elif defined(ANDROID)
#include <android/input.h>
 
extern AInputQueue* AndroidInputQueue;
std::set<int> lJoyId;
std::list<Joypad*> Joypad::lJoypad;
 
void Joypad::updateInputEvent(AInputEvent* event)
{
  std::list<Joypad*>::iterator it;
  for (it = lJoypad.begin(); it != lJoypad.end(); it++)
  {
    (*it)->updateEvent(event);
  }
}
 
Joypad::Joypad(int index)
{
  mConnected = true;
  mStickMode2 = false;
  mDeviceId = -1;
  mIndex = index;
 
  mTick = 0;
 
  for (size_t i = 0; i < 16; i++)
    mDIJoyState.rgbButtons[i] = 0;
 
  for (size_t i = 0; i < 4; i++)
    mDIJoyState.rgdwPOV[i] = -1;
 
  mDIJoyState.lX = 0;
  mDIJoyState.lY = 0;
  mDIJoyState.lRx = 0;
  mDIJoyState.lRy = 0;
  mDIJoyState.rglSlider[0] = 0;
  mDIJoyState.rglSlider[1] = 0;
 
  mIsrunning = true;
  lJoypad.push_back(this);
}
 
Joypad::~Joypad(void)
{
  mIsrunning = false;
 
  if (mDeviceId >= 0)
  {
    std::set<int>::iterator iJoystickIdSearched = lJoyId.find(mDeviceId);
    if (iJoystickIdSearched != lJoyId.end())
      lJoyId.erase(iJoystickIdSearched);
  }
 
  lJoypad.remove(this);
}
 
DIJOYSTATE2* Joypad::initData()
{
  DIJOYSTATE2* data = new DIJOYSTATE2;
  for (size_t i = 0; i < 16; i++)
  {
    data->rgbButtons[i] = mDIJoyState.rgbButtons[i];
  }
 
  for (size_t i = 0; i < 4; i++)
    data->rgdwPOV[i] = mDIJoyState.rgdwPOV[i];
 
  data->lX = mDIJoyState.lX;
  data->lY = mDIJoyState.lY;
  data->lRx = mDIJoyState.lRx;
  data->lRy = mDIJoyState.lRy;
  data->rglSlider[0] = mDIJoyState.rglSlider[0];
  data->rglSlider[1] = mDIJoyState.rglSlider[1];
 
  return data;
}
 
void Joypad::configAxis()
{
  struct android_app* androidApp = (struct android_app*)SCgetExtra("this_inst");
  if (androidApp)
  {
    // get screen orientation from java
    JNIEnv* env;
    ANativeActivity* nativeActivity = androidApp->activity;
    nativeActivity->vm->AttachCurrentThread(&env, NULL);
 
    //TODO setup axis
    //"getDevice", "(I)Landroid/view/InputDevice;"
    //"getMotionRanges", "()Ljava/util/List;"
    //"getAxis", "()I"
 
    jclass cInputDevice = env->FindClass("android/view/InputDevice");
    jmethodID mGetInputDevice = env->GetStaticMethodID(cInputDevice, "getDevice", "(I)Landroid/view/InputDevice;");
    jmethodID mGetMotionRanges = env->GetMethodID(cInputDevice, "getMotionRanges", "()Ljava/util/List;");
 
    jclass cRange = env->FindClass("android/view/InputDevice$MotionRange");
    jmethodID mGetAxis = env->GetMethodID(cRange, "getAxis", "()I");
 
    jobject oDevice = (jobject)env->CallStaticObjectMethod(cInputDevice, mGetInputDevice, (jint)mDeviceId);
    if (!env->ExceptionCheck() && oDevice)
    {
      jobject oMotionRanges = (jobject)env->CallObjectMethod(oDevice, mGetMotionRanges);
      jclass cList = env->FindClass("java/util/List");
      jmethodID mSize = env->GetMethodID(cList, "size", "()I");
      jmethodID mGet = env->GetMethodID(cList, "get", "(I)Ljava/lang/Object;");
 
      if (!env->ExceptionCheck() && oMotionRanges)
      {
        int length = env->CallIntMethod(oMotionRanges, mSize);
        for (int i = 0; i < length; i++)
        {
          jobject oRange = (jobject)env->CallObjectMethod(oMotionRanges, mGet, (jint)i);
          int axis = (int)env->CallIntMethod(oRange, mGetAxis);
 
          if (axis == AMOTION_EVENT_AXIS_RX || axis == AMOTION_EVENT_AXIS_RY)
            mStickMode2 = true;
 
          env->DeleteLocalRef(oRange);
        }
 
        env->DeleteLocalRef(oMotionRanges);
      }
      env->DeleteLocalRef(oDevice);
    }
 
    if (env->ExceptionCheck())
      env->ExceptionClear();
 
    // release env
    nativeActivity->vm->DetachCurrentThread();
  }
}
 
void Joypad::updateEvent(AInputEvent* event)
{
  bool haveData = false;
  int32_t source = AInputEvent_getSource(event);
  int32_t eventType = AInputEvent_getType(event);
  int deviceid = AInputEvent_getDeviceId(event);
 
  switch (eventType)
  {
  case AINPUT_EVENT_TYPE_KEY:
  {
    int32_t keycode = AKeyEvent_getKeyCode(event);
    int32_t action = AKeyEvent_getAction(event);
 
    int state = (action == AKEY_EVENT_ACTION_DOWN) ? 1 : 0;
    int pos = -1;
 
    switch (keycode)
    {
    case AKEYCODE_BUTTON_A:
    case AKEYCODE_BUTTON_1:
      pos = 0;
      break;
    case AKEYCODE_BUTTON_B:
    case AKEYCODE_BUTTON_2:
      pos = 1;
      break;
    case AKEYCODE_BUTTON_X:
    case AKEYCODE_BUTTON_3:
      pos = 2;
      break;
    case AKEYCODE_BUTTON_Y:
    case AKEYCODE_BUTTON_4:
      pos = 3;
      break;
    case AKEYCODE_BUTTON_L1:
    case AKEYCODE_BUTTON_5:
      pos = 4;
      break;
    case AKEYCODE_BUTTON_L2:
    case AKEYCODE_BUTTON_6:
      pos = 5;
      break;
    case AKEYCODE_BUTTON_SELECT:
    case AKEYCODE_BUTTON_7:
      pos = 6;
      break;
    case AKEYCODE_BUTTON_START:
    case AKEYCODE_BUTTON_8:
      pos = 7;
      break;
    case AKEYCODE_BUTTON_THUMBL:
    case AKEYCODE_BUTTON_9:
      pos = 8;
      break;
    case AKEYCODE_BUTTON_THUMBR:
    case AKEYCODE_BUTTON_10:
      pos = 9;
      break;
    case AKEYCODE_BUTTON_C:
    case AKEYCODE_BUTTON_11:
      pos = 10;
      break;
    case AKEYCODE_BUTTON_Z:
    case AKEYCODE_BUTTON_12:
      pos = 11;
      break;
    case AKEYCODE_BUTTON_R1:
    case AKEYCODE_BUTTON_13:
      pos = 12;
      break;
    case AKEYCODE_BUTTON_R2:
    case AKEYCODE_BUTTON_14:
      pos = 13;
      break;
    case AKEYCODE_BUTTON_MODE:
    case AKEYCODE_BUTTON_15:
      pos = 14;
      break;
    case AKEYCODE_BUTTON_16:
      pos = 15;
      break;
    }
 
    if (pos >= 0)
    {
      //TODO use mIndex
      std::set<int>::iterator iJoystickIdSearched = lJoyId.find(deviceid);
      if (mDeviceId == -1 && iJoystickIdSearched == lJoyId.end())
      {
        mDeviceId = deviceid;
        lJoyId.insert(mDeviceId);
        configAxis();
      }
      else if (mDeviceId != deviceid)
        return;
 
      haveData = true;
      mDIJoyState.rgbButtons[pos] = state;
    }
    break;
  }
  case AINPUT_EVENT_TYPE_MOTION:
  {
    if ((source != AINPUT_SOURCE_GAMEPAD) && (source != AINPUT_SOURCE_JOYSTICK))
      return;
 
    std::set<int>::iterator iJoystickIdSearched = lJoyId.find(deviceid);
    if (mDeviceId == -1 && iJoystickIdSearched == lJoyId.end())
    {
      mDeviceId = deviceid;
      lJoyId.insert(mDeviceId);
      configAxis();
    }
    else if (mDeviceId != deviceid)
      return;
 
    haveData = true;
    for (size_t p = 0; p < AMotionEvent_getPointerCount(event); p++)
    {
      mDIJoyState.lX = (int)(AMotionEvent_getAxisValue(event, AMOTION_EVENT_AXIS_X, p) * 1000.0f);
      mDIJoyState.lY = (int)(AMotionEvent_getAxisValue(event, AMOTION_EVENT_AXIS_Y, p) * 1000.0f);
 
      // XBOX 360 Wireless
      if (mStickMode2)
      {
        mDIJoyState.lRx = (int)(AMotionEvent_getAxisValue(event, AMOTION_EVENT_AXIS_RX, p) * 1000.0f);
        mDIJoyState.lRy = (int)(AMotionEvent_getAxisValue(event, AMOTION_EVENT_AXIS_RY, p) * 1000.0f);
        mDIJoyState.rglSlider[0] = (int)(AMotionEvent_getAxisValue(event, AMOTION_EVENT_AXIS_Z, p) * 1000.0f);
        mDIJoyState.rglSlider[1] = (int)(AMotionEvent_getAxisValue(event, AMOTION_EVENT_AXIS_RZ, p) * 1000.0f);
      }
      else
        // XBOX 360 Wired
      {
        mDIJoyState.lRx = (int)(AMotionEvent_getAxisValue(event, AMOTION_EVENT_AXIS_Z, p) * 1000.0f);
        mDIJoyState.lRy = (int)(AMotionEvent_getAxisValue(event, AMOTION_EVENT_AXIS_RZ, p) * 1000.0f);
        mDIJoyState.rglSlider[0] = (int)(AMotionEvent_getAxisValue(event, AMOTION_EVENT_AXIS_LTRIGGER, p) * 1000.0f);
        mDIJoyState.rglSlider[1] = (int)(AMotionEvent_getAxisValue(event, AMOTION_EVENT_AXIS_RTRIGGER, p) * 1000.0f);
      }
 
      //POV (sames values as windows)
      DWORD pov = -1;
      float px = (int)(AMotionEvent_getAxisValue(event, AMOTION_EVENT_AXIS_HAT_X, p) * 1000.0f);
      float py = (int)(AMotionEvent_getAxisValue(event, AMOTION_EVENT_AXIS_HAT_Y, p) * 1000.0f);
 
      if (px == 0.0f && py == 0.0f)
        pov = -1;
      else if (px == 0.0f && py < 0.0f)
        pov = 0;
      else if (px > 0.0f && py < 0.0f)
        pov = 4500;
      else if (px > 0.0f && py == 0.0f)
        pov = 9000;
      else if (px > 0.0f && py > 0.0f)
        pov = 13500;
      else if (px == 0.0f && py > 0.0f)
        pov = 18000;
      else if (px < 0.0f && py > 0.0f)
        pov = 22500;
      else if (px < 0.0f && py == 0.0f)
        pov = 27000;
      else if (px < 0.0f && py < 0.0f)
        pov = 31500;
 
      mDIJoyState.rgdwPOV[0] = pov;
    }
    break;
  }
  }
 
  int elapsedTime = (GetTickCount() - mTick);
  if (haveData && ((elapsedTime > 16) || mTick == 0))
  {
    //event
    DIJOYSTATE2* ndata = initData();
    mTick = GetTickCount();
    OBJpostEvent(JOYPAD_DATA_CB, SCOL_PTR this, SCOL_PTR ndata);
  }
}
 
bool Joypad::IsConnected()
{
  return mConnected;
}
 
bool Joypad::IsRunning()
{
  return mIsrunning;
}
 
bool Joypad::StartRumble(float intensity)
{
  //not implemented
  return false;
}
 
void Joypad::StopRumble()
{
  //not implemented
}
 
#else // QT
 
#ifdef SCOL_STATIC
# include <QtPlugin>
 
# if defined (_WIN32)
Q_IMPORT_PLUGIN(QXInputGamepadBackendPlugin)
# elif defined(ANDROID)
Q_IMPORT_PLUGIN(QAndroidGamepadBackendPlugin)
# elif defined (OSX) || defined(APPLE_IOS)
Q_IMPORT_PLUGIN(QDarwinGamepadBackendPlugin)
# else // LINUX
Q_IMPORT_PLUGIN(QEvdevGamepadBackendPlugin)
# endif
 
#endif // SCOL_STATIC
 
Joypad::Joypad(int index) : QObject(QCoreApplication::instance())
{
  mTick = 0;
  mIndex = index;
 
  for (size_t i = 0; i < 16; i++)
    mDIJoyState.rgbButtons[i] = 0;
 
  for (size_t i = 0; i < 4; i++)
    mDIJoyState.rgdwPOV[i] = -1;
 
  mDIJoyState.lX = 0;
  mDIJoyState.lY = 0;
  mDIJoyState.lRx = 0;
  mDIJoyState.lRy = 0;
  mDIJoyState.rglSlider[0] = 0;
  mDIJoyState.rglSlider[1] = 0;
 
  mGamepad = NULL;
  mConnected = false;
 
  // Run thread
  mIsrunning = true;
 
  //mThread = boost::thread(boost::bind(&Joypad::run, this));
  run();
}
 
Joypad::~Joypad()
{
  mIsrunning = false;
  //mThread.join();
 
  SAFE_DELETE(mGamepad);
}
 
void Joypad::initData()
{
  mConnected = mGamepad->isConnected();
  if (mConnected)
  {
    mDIJoyState.rgbButtons[0] = mGamepad->buttonA();
    mDIJoyState.rgbButtons[1] = mGamepad->buttonB();
    mDIJoyState.rgbButtons[2] = mGamepad->buttonX();
    mDIJoyState.rgbButtons[3] = mGamepad->buttonY();
    mDIJoyState.rgbButtons[4] = mGamepad->buttonL1();
    mDIJoyState.rgbButtons[5] = mGamepad->buttonL2();
    mDIJoyState.rgbButtons[6] = mGamepad->buttonSelect();
    mDIJoyState.rgbButtons[7] = mGamepad->buttonStart();
    mDIJoyState.rgbButtons[8] = mGamepad->buttonL3();
    mDIJoyState.rgbButtons[9] = mGamepad->buttonR3();
    mDIJoyState.rgbButtons[10] = 0;
    mDIJoyState.rgbButtons[11] = 0;
    mDIJoyState.rgbButtons[12] = mGamepad->buttonR1();
    mDIJoyState.rgbButtons[13] = mGamepad->buttonR2();
    mDIJoyState.rgbButtons[14] = mGamepad->buttonGuide();
 
    mDIJoyState.lX = (int)(mGamepad->axisLeftX() * 1000.0f);
    mDIJoyState.lY = (int)(mGamepad->axisLeftY() * 1000.0f);
    mDIJoyState.lRx = (int)(mGamepad->axisRightX() * 1000.0f);
    mDIJoyState.lRy = (int)(mGamepad->axisRightY() * 1000.0f);
 
    //POV (sames values as windows)
    DWORD pov = -1;
 
    if (mGamepad->buttonCenter())
      pov = -1;
    else if (!mGamepad->buttonLeft() && !mGamepad->buttonRight() && mGamepad->buttonUp())
      pov = 0;
    else if (mGamepad->buttonRight() && mGamepad->buttonUp())
      pov = 4500;
    else if (mGamepad->buttonRight() && !mGamepad->buttonDown() && !mGamepad->buttonUp())
      pov = 9000;
    else if (mGamepad->buttonRight() && mGamepad->buttonDown())
      pov = 13500;
    else if (!mGamepad->buttonLeft() && !mGamepad->buttonRight() && mGamepad->buttonDown())
      pov = 18000;
    else if (mGamepad->buttonLeft() && mGamepad->buttonDown())
      pov = 22500;
    else if (mGamepad->buttonLeft() && !mGamepad->buttonDown() && !mGamepad->buttonUp())
      pov = 27000;
    else if (mGamepad->buttonLeft() && mGamepad->buttonUp())
      pov = 31500;
 
    mDIJoyState.rgdwPOV[0] = pov;
 
    DIJOYSTATE2* data = new DIJOYSTATE2;
    for (size_t i = 0; i < 16; i++)
    {
      data->rgbButtons[i] = mDIJoyState.rgbButtons[i];
    }
 
    for (size_t i = 0; i < 4; i++)
      data->rgdwPOV[i] = mDIJoyState.rgdwPOV[i];
 
    data->lX = mDIJoyState.lX;
    data->lY = mDIJoyState.lY;
    data->lRx = mDIJoyState.lRx;
    data->lRy = mDIJoyState.lRy;
    data->rglSlider[0] = mDIJoyState.rglSlider[0];
    data->rglSlider[1] = mDIJoyState.rglSlider[1];
 
    //event
    OBJpostEvent(JOYPAD_DATA_CB, SCOL_PTR this, SCOL_PTR data);
  }
}
 
void Joypad::updateDoubleData(double value)
{
  initData();
}
 
void Joypad::updateBoolData(bool value)
{
  initData();
}
 
void Joypad::run()
{
  if (!mGamepad)
  {
    const QList<int> gamepads = QGamepadManager::instance()->connectedGamepads();
    if (gamepads.isEmpty())
    {
      mConnected = false;
    }
    else
    {
      //TODO use mIndex
      mGamepad = new QGamepad(*gamepads.begin(), this);
 
      connect(mGamepad, SIGNAL(connectedChanged(bool)), this, SLOT(updateBoolData(double)));
      connect(mGamepad, SIGNAL(axisLeftXChanged(double)), this, SLOT(updateDoubleData(double)));
      connect(mGamepad, SIGNAL(axisLeftYChanged(double)), this, SLOT(updateDoubleData(double)));
      connect(mGamepad, SIGNAL(axisRightXChanged(double)), this, SLOT(updateDoubleData(double)));
      connect(mGamepad, SIGNAL(axisRightYChanged(double)), this, SLOT(updateDoubleData(double)));
      connect(mGamepad, SIGNAL(buttonAChanged(bool)), this, SLOT(updateBoolData(bool)));
      connect(mGamepad, SIGNAL(buttonBChanged(bool)), this, SLOT(updateBoolData(bool)));
      connect(mGamepad, SIGNAL(buttonYChanged(bool)), this, SLOT(updateBoolData(bool)));
      connect(mGamepad, SIGNAL(buttonL1Changed(bool)), this, SLOT(updateBoolData(bool)));
      connect(mGamepad, SIGNAL(buttonR1Changed(bool)), this, SLOT(updateBoolData(bool)));
      connect(mGamepad, SIGNAL(buttonL2Changed(double)), this, SLOT(updateDoubleData(double)));
      connect(mGamepad, SIGNAL(buttonR2Changed(double)), this, SLOT(updateDoubleData(double)));
      connect(mGamepad, SIGNAL(buttonL3Changed(bool)), this, SLOT(updateBoolData(bool)));
      connect(mGamepad, SIGNAL(buttonR3Changed(bool)), this, SLOT(updateBoolData(bool)));
      connect(mGamepad, SIGNAL(buttonSelectChanged(bool)), this, SLOT(updateBoolData(bool)));
      connect(mGamepad, SIGNAL(buttonStartChanged(bool)), this, SLOT(updateBoolData(bool)));
      connect(mGamepad, SIGNAL(buttonGuideChanged(bool)), this, SLOT(updateBoolData(bool)));
      connect(mGamepad, SIGNAL(buttonUpChanged(bool)), this, SLOT(updateBoolData(bool)));
      connect(mGamepad, SIGNAL(buttonDownChanged(bool)), this, SLOT(updateBoolData(bool)));
      connect(mGamepad, SIGNAL(buttonLeftChanged(bool)), this, SLOT(updateBoolData(bool)));
      connect(mGamepad, SIGNAL(buttonRightChanged(bool)), this, SLOT(updateBoolData(bool)));
      connect(mGamepad, SIGNAL(buttonCenterChanged(bool)), this, SLOT(updateBoolData(bool)));
    }
  }
}
/*
void Joypad::run()
{
  try
  {
    // get new data 30 time a second
    while(mIsrunning)
    {
      boost::mutex::scoped_lock l(mMutex);
      mTick = GetTickCount();
 
      if (!mGamepad)
      {
        const QList<int> gamepads = QGamepadManager::instance()->connectedGamepads();
        if (gamepads.isEmpty())
        {
          mConnected = false;
        }
        else
        {
          mGamepad = new QGamepad(*gamepads.begin(), QCoreApplication::instance());
          mConnected = mGamepad->isConnected();
        }
      }
 
      if(mGamepad && !mGamepad->isConnected())
        boost::this_thread::sleep_for(boost::chrono::milliseconds(200));
 
      mConnected = (mGamepad) ? mGamepad->isConnected() : false;
      if (mConnected)
      {
        mDIJoyState.rgbButtons[0] = mGamepad->buttonA();
        mDIJoyState.rgbButtons[1] = mGamepad->buttonB();
        mDIJoyState.rgbButtons[2] = mGamepad->buttonX();
        mDIJoyState.rgbButtons[3] = mGamepad->buttonY();
        mDIJoyState.rgbButtons[4] = mGamepad->buttonL1();
        mDIJoyState.rgbButtons[5] = mGamepad->buttonL2();
        mDIJoyState.rgbButtons[6] = mGamepad->buttonSelect();
        mDIJoyState.rgbButtons[7] = mGamepad->buttonStart();
        mDIJoyState.rgbButtons[8] = mGamepad->buttonL3();
        mDIJoyState.rgbButtons[9] = mGamepad->buttonR3();
        mDIJoyState.rgbButtons[10] = 0;
        mDIJoyState.rgbButtons[11] = 0;
        mDIJoyState.rgbButtons[12] = mGamepad->buttonR1();
        mDIJoyState.rgbButtons[13] = mGamepad->buttonR2();
        mDIJoyState.rgbButtons[14] = mGamepad->buttonGuide();
 
        mDIJoyState.lX = (int)(mGamepad->axisLeftX() * 1000.0f);
        mDIJoyState.lY = (int)(mGamepad->axisLeftY() * 1000.0f);
        mDIJoyState.lRx= (int)(mGamepad->axisRightX() * 1000.0f);
        mDIJoyState.lRy = (int)(mGamepad->axisRightY() * 1000.0f);
 
        //POV (sames values as windows)
        DWORD pov = -1;
 
        if (mGamepad->buttonCenter())
          pov = -1;
        else if (!mGamepad->buttonDown() && !mGamepad->buttonUp() && mGamepad->buttonLeft())
          pov = 0;
        else if (mGamepad->buttonRight() && mGamepad->buttonDown())
          pov = 4500;
        else if (mGamepad->buttonRight() && !mGamepad->buttonDown() && !mGamepad->buttonUp())
          pov = 9000;
        else if (mGamepad->buttonRight() && mGamepad->buttonUp())
          pov = 13500;
        else if (mGamepad->buttonLeft() && mGamepad->buttonRight() && mGamepad->buttonUp())
          pov = 18000;
        else if (mGamepad->buttonLeft() && mGamepad->buttonUp())
          pov = 22500;
        else if (mGamepad->buttonLeft() && !mGamepad->buttonDown() && !mGamepad->buttonUp())
          pov = 27000;
        else if (mGamepad->buttonLeft() && mGamepad->buttonDown())
          pov = 31500;
 
        mDIJoyState.rgdwPOV[0] = pov;
      }
 
      int elapsedTime = (GetTickCount() - mTick);
      if ((elapsedTime > 16) || mTick == 0)
      {
        //event
        DIJOYSTATE2* ndata = initData();
        mTick = GetTickCount();
        OBJpostEvent(JOYPAD_DATA_CB, SCOL_PTR this, SCOL_PTR ndata);
      }
 
      elapsedTime = 33 - (GetTickCount() - mTick);
      if (elapsedTime > 0)
        boost::this_thread::sleep_for(boost::chrono::milliseconds(elapsedTime));
    }
  }
  catch(std::exception ex)
  {
    MMechostr(MSKDEBUG,"Joypad > error thread : %s \n", ex.what());
  }
}
*/
bool Joypad::IsConnected()
{
  //boost::mutex::scoped_lock l(mMutex);
  return mConnected;
}
 
bool Joypad::IsRunning()
{
  //boost::mutex::scoped_lock l(mMutex);
  return mIsrunning;
}
 
bool Joypad::StartRumble(float intensity)
{
  //not implemented
  return false;
}
 
void Joypad::StopRumble()
{
  //not implemented
}
 
#endif