kc3-lang/SDL/src/joystick/hidapi/SDL_hidapi_steam.c

• Show log

  Commit

• Hash : b6afbe63
  Author :
  Date : 2020-04-07T09:38:57
  

  Added SDL_log.h to SDL_internal.h so logging is available everywhere

Download

• src/joystick/hidapi/SDL_hidapi_steam.c

• /*
    Simple DirectMedia Layer
    Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org>
  
    This software is provided 'as-is', without any express or implied
    warranty.  In no event will the authors be held liable for any damages
    arising from the use of this software.
  
    Permission is granted to anyone to use this software for any purpose,
    including commercial applications, and to alter it and redistribute it
    freely, subject to the following restrictions:
  
    1. The origin of this software must not be misrepresented; you must not
       claim that you wrote the original software. If you use this software
       in a product, an acknowledgment in the product documentation would be
       appreciated but is not required.
    2. Altered source versions must be plainly marked as such, and must not be
       misrepresented as being the original software.
    3. This notice may not be removed or altered from any source distribution.
  */
  #include "../../SDL_internal.h"
  
  #ifdef SDL_JOYSTICK_HIDAPI
  
  #include "SDL_hints.h"
  #include "SDL_events.h"
  #include "SDL_timer.h"
  #include "SDL_joystick.h"
  #include "SDL_gamecontroller.h"
  #include "../SDL_sysjoystick.h"
  #include "SDL_hidapijoystick_c.h"
  
  
  
  #ifdef SDL_JOYSTICK_HIDAPI_STEAM
  
  /*****************************************************************************************************/
  
  #include <stdint.h>
  
  typedef enum
  {
      false,
      true
  } bool;
  
  typedef uint32_t uint32;
  typedef uint64_t uint64;
      
  #include "steam/controller_constants.h"
  #include "steam/controller_structs.h"
  
  typedef struct SteamControllerStateInternal_t
  {
      // Controller Type for this Controller State
      uint32 eControllerType;
  
      // If packet num matches that on your prior call, then the controller state hasn't been changed since 
      // your last call and there is no need to process it
      uint32 unPacketNum;
      
      // bit flags for each of the buttons
      uint64 ulButtons;
      
      // Left pad coordinates
      short sLeftPadX;
      short sLeftPadY;
      
      // Right pad coordinates
      short sRightPadX;
      short sRightPadY;
  
      // Center pad coordinates
      short sCenterPadX;
      short sCenterPadY;
      
      // Left analog stick coordinates
      short sLeftStickX;
      short sLeftStickY;
  
      // Right analog stick coordinates
      short sRightStickX;
      short sRightStickY;
      
      unsigned short sTriggerL;
      unsigned short sTriggerR;
      
      short sAccelX;
      short sAccelY;
      short sAccelZ;
      
      short sGyroX;
      short sGyroY;
      short sGyroZ;
      
      float sGyroQuatW;
      float sGyroQuatX;
      float sGyroQuatY;
      float sGyroQuatZ;
      
      short sGyroSteeringAngle;
      
      unsigned short sBatteryLevel;
  
      // Pressure sensor data.
      unsigned short sPressurePadLeft;
      unsigned short sPressurePadRight;
      
      unsigned short sPressureBumperLeft;
      unsigned short sPressureBumperRight;
      
      // Internal state data
      short sPrevLeftPad[2];
      short sPrevLeftStick[2];
  } SteamControllerStateInternal_t;
  
  
  /* Defines for ulButtons in SteamControllerStateInternal_t */
  #define STEAM_RIGHT_TRIGGER_MASK            0x00000001
  #define STEAM_LEFT_TRIGGER_MASK             0x00000002
  #define STEAM_RIGHT_BUMPER_MASK             0x00000004
  #define STEAM_LEFT_BUMPER_MASK              0x00000008
  #define STEAM_BUTTON_0_MASK                 0x00000010    /* Y */
  #define STEAM_BUTTON_1_MASK                 0x00000020    /* B */
  #define STEAM_BUTTON_2_MASK                 0x00000040    /* X */
  #define STEAM_BUTTON_3_MASK                 0x00000080    /* A */
  #define STEAM_TOUCH_0_MASK                  0x00000100    /* DPAD UP */
  #define STEAM_TOUCH_1_MASK                  0x00000200    /* DPAD RIGHT */
  #define STEAM_TOUCH_2_MASK                  0x00000400    /* DPAD LEFT */
  #define STEAM_TOUCH_3_MASK                  0x00000800    /* DPAD DOWN */
  #define STEAM_BUTTON_MENU_MASK              0x00001000    /* SELECT */
  #define STEAM_BUTTON_STEAM_MASK             0x00002000    /* GUIDE */
  #define STEAM_BUTTON_ESCAPE_MASK            0x00004000    /* START */
  #define STEAM_BUTTON_BACK_LEFT_MASK         0x00008000
  #define STEAM_BUTTON_BACK_RIGHT_MASK        0x00010000
  #define STEAM_BUTTON_LEFTPAD_CLICKED_MASK   0x00020000
  #define STEAM_BUTTON_RIGHTPAD_CLICKED_MASK  0x00040000
  #define STEAM_LEFTPAD_FINGERDOWN_MASK       0x00080000
  #define STEAM_RIGHTPAD_FINGERDOWN_MASK      0x00100000
  #define STEAM_JOYSTICK_BUTTON_MASK            0x00400000
  #define STEAM_LEFTPAD_AND_JOYSTICK_MASK        0x00800000
  
  
  // Look for report version 0x0001, type WIRELESS (3), length >= 1 byte
  #define D0G_IS_VALID_WIRELESS_EVENT(data, len)    ((len) >= 5 && (data)[0] == 1 && (data)[1] == 0 && (data)[2] == 3 && (data)[3] >= 1)
  #define D0G_GET_WIRELESS_EVENT_TYPE(data)        ((data)[4])
  #define D0G_WIRELESS_DISCONNECTED    1
  #define D0G_WIRELESS_ESTABLISHED    2
  #define D0G_WIRELESS_NEWLYPAIRED    3
  
  #define D0G_IS_WIRELESS_DISCONNECT(data, len)    ( D0G_IS_VALID_WIRELESS_EVENT(data,len) && D0G_GET_WIRELESS_EVENT_TYPE(data) == D0G_WIRELESS_DISCONNECTED )
  
  #define MAX_REPORT_SEGMENT_PAYLOAD_SIZE    18
  /*
   * SteamControllerPacketAssembler has to be used when reading output repots from controllers.
   */
  typedef struct
  {
      uint8_t uBuffer[ MAX_REPORT_SEGMENT_PAYLOAD_SIZE * 8 + 1 ];
      int nExpectedSegmentNumber;
      bool bIsBle;
  } SteamControllerPacketAssembler;
  
  
  #undef clamp
  #define clamp(val, min, max) (((val) > (max)) ? (max) : (((val) < (min)) ? (min) : (val)))
  
  #undef offsetof
  #define offsetof(s,m)    (size_t)&(((s *)0)->m)
  
  #ifdef DEBUG_STEAM_CONTROLLER
  #define DPRINTF(format, ...) printf(format, ##__VA_ARGS__)
  #define HEXDUMP(ptr, len) hexdump(ptr, len)
  #else
  #define DPRINTF(format, ...)
  #define HEXDUMP(ptr, len)
  #endif
  #define printf  SDL_Log
  
  #define MAX_REPORT_SEGMENT_SIZE        ( MAX_REPORT_SEGMENT_PAYLOAD_SIZE + 2 )
  #define CALC_REPORT_SEGMENT_NUM(index)  ( ( index / MAX_REPORT_SEGMENT_PAYLOAD_SIZE ) & 0x07 )
  #define REPORT_SEGMENT_DATA_FLAG    0x80
  #define REPORT_SEGMENT_LAST_FLAG    0x40
  #define BLE_REPORT_NUMBER        0x03
  
  #define STEAMCONTROLLER_TRIGGER_MAX_ANALOG 26000
  
  // Enable mouse mode when using the Steam Controller locally
  #undef ENABLE_MOUSE_MODE
  
  
  // Wireless firmware quirk: the firmware intentionally signals "failure" when performing
  // SET_FEATURE / GET_FEATURE when it actually means "pending radio round-trip". The only
  // way to make SET_FEATURE / GET_FEATURE work is to loop several times with a sleep. If
  // it takes more than 50ms to get the response for SET_FEATURE / GET_FEATURE, we assume
  // that the controller has failed.
  #define RADIO_WORKAROUND_SLEEP_ATTEMPTS 50
  #define RADIO_WORKAROUND_SLEEP_DURATION_US 500
  
  // This was defined by experimentation. 2000 seemed to work but to give that extra bit of margin, set to 3ms.
  #define CONTROLLER_CONFIGURATION_DELAY_US 3000
  
  static uint8_t GetSegmentHeader( int nSegmentNumber, bool bLastPacket )
  {
      uint8_t header = REPORT_SEGMENT_DATA_FLAG;
      header |= nSegmentNumber;
      if ( bLastPacket )
          header |= REPORT_SEGMENT_LAST_FLAG;
      
      return header;
  }
  
  static void hexdump( const uint8_t *ptr, int len )
  {
      int i;
      for ( i = 0; i < len ; ++i )
          printf("%02x ", ptr[i]);
      printf("\n");
  }
  
  static void ResetSteamControllerPacketAssembler( SteamControllerPacketAssembler *pAssembler )
  {
      memset( pAssembler->uBuffer, 0, sizeof( pAssembler->uBuffer ) );
      pAssembler->nExpectedSegmentNumber = 0;
  }
  
  static void InitializeSteamControllerPacketAssembler( SteamControllerPacketAssembler *pAssembler )
  {
      /* We only support BLE devices right now */
      pAssembler->bIsBle = true;
      ResetSteamControllerPacketAssembler( pAssembler );
  }
  
  // Returns:
  //     <0 on error
  //     0 on not ready
  //     Complete packet size on completion
  static int WriteSegmentToSteamControllerPacketAssembler( SteamControllerPacketAssembler *pAssembler, const uint8_t *pSegment, int nSegmentLength )
  {
      if ( pAssembler->bIsBle )
      {
          HEXDUMP( pSegment, nSegmentLength );
  
          if ( pSegment[ 0 ] != BLE_REPORT_NUMBER )
          {
              // We may get keyboard/mouse input events until controller stops sending them
              return 0;
          }
          
          if ( nSegmentLength != MAX_REPORT_SEGMENT_SIZE )
          {
              printf( "Bad segment size! %d\n", (int)nSegmentLength );
              hexdump( pSegment, nSegmentLength );
              ResetSteamControllerPacketAssembler( pAssembler );
              return -1;
          }
          
          uint8_t uSegmentHeader = pSegment[ 1 ];
          DPRINTF("GOT PACKET HEADER = 0x%x\n", uSegmentHeader);
          
          if ( ( uSegmentHeader & REPORT_SEGMENT_DATA_FLAG ) == 0 )
          {
              // We get empty segments, just ignore them
              return 0;
          }
          
          int nSegmentNumber = uSegmentHeader & 0x07;
          if ( nSegmentNumber != pAssembler->nExpectedSegmentNumber )
          {
              ResetSteamControllerPacketAssembler( pAssembler );
              
              if ( nSegmentNumber )
              {
                  // This happens occasionally
                  DPRINTF("Bad segment number, got %d, expected %d\n",
                      nSegmentNumber, pAssembler->nExpectedSegmentNumber );
                  return -1;
              }
          }
          
          memcpy( pAssembler->uBuffer + nSegmentNumber * MAX_REPORT_SEGMENT_PAYLOAD_SIZE,
                 pSegment + 2, // ignore header and report number
                 MAX_REPORT_SEGMENT_PAYLOAD_SIZE );
          
          if ( uSegmentHeader & REPORT_SEGMENT_LAST_FLAG )
          {
              pAssembler->nExpectedSegmentNumber = 0;
              return ( nSegmentNumber + 1 ) * MAX_REPORT_SEGMENT_PAYLOAD_SIZE;
          }
          
          pAssembler->nExpectedSegmentNumber++;
      }
      else
      {
          // Just pass through
          memcpy( pAssembler->uBuffer,
                 pSegment,
                 nSegmentLength );
          return nSegmentLength;
      }
      
      return 0;
  }
  
  #define BLE_MAX_READ_RETRIES    8
  
  static int SetFeatureReport( hid_device *dev, unsigned char uBuffer[65], int nActualDataLen )
  {
      DPRINTF("SetFeatureReport %p %p %d\n", dev, uBuffer, nActualDataLen);
      int nRet = -1;
      bool bBle = true; // only wireless/BLE for now, though macOS could do wired in the future
      
      if ( bBle )
      {
          if ( nActualDataLen < 1 )
              return -1;
          
          int nSegmentNumber = 0;
          uint8_t uPacketBuffer[ MAX_REPORT_SEGMENT_SIZE ];
          
          // Skip report number in data
          unsigned char *pBufferPtr = uBuffer + 1;
          nActualDataLen--;
          
          while ( nActualDataLen > 0 )
          {
              int nBytesInPacket = nActualDataLen > MAX_REPORT_SEGMENT_PAYLOAD_SIZE ? MAX_REPORT_SEGMENT_PAYLOAD_SIZE : nActualDataLen;
              
              nActualDataLen -= nBytesInPacket;
  
              // Construct packet
              memset( uPacketBuffer, 0, sizeof( uPacketBuffer ) );
              uPacketBuffer[ 0 ] = BLE_REPORT_NUMBER;
              uPacketBuffer[ 1 ] = GetSegmentHeader( nSegmentNumber, nActualDataLen == 0 );
              memcpy( &uPacketBuffer[ 2 ], pBufferPtr, nBytesInPacket );
              
              pBufferPtr += nBytesInPacket;
              nSegmentNumber++;
              
              nRet = hid_send_feature_report( dev, uPacketBuffer, sizeof( uPacketBuffer ) );
              DPRINTF("SetFeatureReport() ret = %d\n", nRet);
          }
      }
      
      return nRet;
  }
  
  static int GetFeatureReport( hid_device *dev, unsigned char uBuffer[65] )
  {
      DPRINTF("GetFeatureReport( %p %p )\n", dev, uBuffer );
      int nRet = -1;
      bool bBle = true;
  
      if ( bBle )
      {
          SteamControllerPacketAssembler assembler;
          InitializeSteamControllerPacketAssembler( &assembler );
          
          int nRetries = 0;
          uint8_t uSegmentBuffer[ MAX_REPORT_SEGMENT_SIZE ];
          while( nRetries < BLE_MAX_READ_RETRIES )
          {
              memset( uSegmentBuffer, 0, sizeof( uSegmentBuffer ) );
              uSegmentBuffer[ 0 ] = BLE_REPORT_NUMBER;
              nRet = hid_get_feature_report( dev, uSegmentBuffer, sizeof( uSegmentBuffer ) );
              DPRINTF( "GetFeatureReport ble ret=%d\n", nRet );
              HEXDUMP( uSegmentBuffer, nRet );
              
              // Zero retry counter if we got data
              if ( nRet > 2 && ( uSegmentBuffer[ 1 ] & REPORT_SEGMENT_DATA_FLAG ) )
                  nRetries = 0;
              else
                  nRetries++;
              
              if ( nRet > 0 )
              {
                  int nPacketLength = WriteSegmentToSteamControllerPacketAssembler( &assembler,
                                                                                   uSegmentBuffer,
                                                                                   nRet );
                  
                  if ( nPacketLength > 0 && nPacketLength < 65 )
                  {
                      // Leave space for "report number"
                      uBuffer[ 0 ] = 0;
                      memcpy( uBuffer + 1, assembler.uBuffer, nPacketLength );
                      return nPacketLength;
                  }
              }
              
              
          }
          printf("Could not get a full ble packet after %d retries\n", nRetries );
          return -1;
      }
      
      return nRet;
  }
  
  static int ReadResponse( hid_device *dev, uint8_t uBuffer[65], int nExpectedResponse )
  {
      DPRINTF("ReadResponse( %p %p %d )\n", dev, uBuffer, nExpectedResponse );
      int nRet = GetFeatureReport( dev, uBuffer );
  
      if ( nRet < 0 )
          return nRet;
      
      DPRINTF("ReadResponse got %d bytes of data: ", nRet );
      HEXDUMP( uBuffer, nRet );
      
      if ( uBuffer[1] != nExpectedResponse )
          return -1;
      
      return nRet;
  }
  
  //---------------------------------------------------------------------------
  // Reset steam controller (unmap buttons and pads) and re-fetch capability bits
  //---------------------------------------------------------------------------
  static bool ResetSteamController( hid_device *dev, bool bSuppressErrorSpew )
  {
      DPRINTF( "ResetSteamController hid=%p\n", dev );
      // Firmware quirk: Set Feature and Get Feature requests always require a 65-byte buffer.
      unsigned char buf[65];
      int res = -1;
      
      buf[0] = 0;
      buf[1] = ID_GET_ATTRIBUTES_VALUES;
      res = SetFeatureReport( dev, buf, 2 );
      if ( res < 0 )
      {
          if ( !bSuppressErrorSpew )
              printf( "GET_ATTRIBUTES_VALUES failed for controller %p\n", dev );
          return false;
      }
      
      // Retrieve GET_ATTRIBUTES_VALUES result
      // Wireless controller endpoints without a connected controller will return nAttrs == 0
      res = ReadResponse( dev, buf, ID_GET_ATTRIBUTES_VALUES );
      if ( res < 0 || buf[1] != ID_GET_ATTRIBUTES_VALUES )
      {
          HEXDUMP(buf, res);
          if ( !bSuppressErrorSpew )
              printf( "Bad GET_ATTRIBUTES_VALUES response for controller %p\n", dev );
          return false;
      }
      
      int nAttributesLength = buf[ 2 ];
      if ( nAttributesLength > res )
      {
          if ( !bSuppressErrorSpew )
              printf( "Bad GET_ATTRIBUTES_VALUES response for controller %p\n", dev );
          return false;
      }
      
      // Clear digital button mappings
      buf[0] = 0;
      buf[1] = ID_CLEAR_DIGITAL_MAPPINGS;
      res = SetFeatureReport( dev, buf, 2 );
      if ( res < 0 )
      {
          if ( !bSuppressErrorSpew )
              printf( "CLEAR_DIGITAL_MAPPINGS failed for controller %p\n", dev );
          return false;
      }
      
      // Reset the default settings
      memset( buf, 0, 65 );
      buf[1] = ID_LOAD_DEFAULT_SETTINGS;
      buf[2] = 0;
      res = SetFeatureReport( dev, buf, 3 );
      if ( res < 0 )
      {
          if ( !bSuppressErrorSpew )
              printf( "LOAD_DEFAULT_SETTINGS failed for controller %p\n", dev );
          return false;
      }
      
      // Apply custom settings - clear trackpad modes (cancel mouse emulation), etc
      int nSettings = 0;
  #define ADD_SETTING(SETTING, VALUE)    \
  buf[3+nSettings*3] = SETTING;    \
  buf[3+nSettings*3+1] = ((uint16_t)VALUE)&0xFF; \
  buf[3+nSettings*3+2] = ((uint16_t)VALUE)>>8; \
  ++nSettings;
      
      memset( buf, 0, 65 );
      buf[1] = ID_SET_SETTINGS_VALUES;
      ADD_SETTING( SETTING_WIRELESS_PACKET_VERSION, 2 );
      ADD_SETTING( SETTING_LEFT_TRACKPAD_MODE, TRACKPAD_NONE );
  #ifdef ENABLE_MOUSE_MODE
      ADD_SETTING( SETTING_RIGHT_TRACKPAD_MODE, TRACKPAD_ABSOLUTE_MOUSE );
      ADD_SETTING( SETTING_SMOOTH_ABSOLUTE_MOUSE, 1 );
      ADD_SETTING( SETTING_MOMENTUM_MAXIMUM_VELOCITY, 20000 );    // [0-20000] default 8000
      ADD_SETTING( SETTING_MOMENTUM_DECAY_AMMOUNT, 50 );        // [0-50] default 5
  #else
      ADD_SETTING( SETTING_RIGHT_TRACKPAD_MODE, TRACKPAD_NONE );
      ADD_SETTING( SETTING_SMOOTH_ABSOLUTE_MOUSE, 0 );
  #endif
      buf[2] = nSettings*3;
      
      res = SetFeatureReport( dev, buf, 3+nSettings*3 );
      if ( res < 0 )
      {
          if ( !bSuppressErrorSpew )
              printf( "SET_SETTINGS failed for controller %p\n", dev );
          return false;
      }
      
  #ifdef ENABLE_MOUSE_MODE
      // Wait for ID_CLEAR_DIGITAL_MAPPINGS to be processed on the controller
      bool bMappingsCleared = false;
      int iRetry;
      for ( iRetry = 0; iRetry < 2; ++iRetry )
      {
          memset( buf, 0, 65 );
          buf[1] = ID_GET_DIGITAL_MAPPINGS;
          buf[2] = 1; // one byte - requesting from index 0
          buf[3] = 0;
          res = SetFeatureReport( dev, buf, 4 );
          if ( res < 0 )
          {
              printf( "GET_DIGITAL_MAPPINGS failed for controller %p\n", dev );
              return false;
          }
          
          res = ReadResponse( dev, buf, ID_GET_DIGITAL_MAPPINGS );
          if ( res < 0 || buf[1] != ID_GET_DIGITAL_MAPPINGS )
          {
              printf( "Bad GET_DIGITAL_MAPPINGS response for controller %p\n", dev );
              return false;
          }
          
          // If the length of the digital mappings result is not 1 (index byte, no mappings) then clearing hasn't executed
          if ( buf[2] == 1 && buf[3] == 0xFF )
          {
              bMappingsCleared = true;
              break;
          }
          usleep( CONTROLLER_CONFIGURATION_DELAY_US );
      }
      
      if ( !bMappingsCleared && !bSuppressErrorSpew )
      {
          printf( "Warning: CLEAR_DIGITAL_MAPPINGS never completed for controller %p\n", dev );
      }
      
      // Set our new mappings
      memset( buf, 0, 65 );
      buf[1] = ID_SET_DIGITAL_MAPPINGS;
      buf[2] = 6; // 2 settings x 3 bytes
      buf[3] = IO_DIGITAL_BUTTON_RIGHT_TRIGGER;
      buf[4] = DEVICE_MOUSE;
      buf[5] = MOUSE_BTN_LEFT;
      buf[6] = IO_DIGITAL_BUTTON_LEFT_TRIGGER;
      buf[7] = DEVICE_MOUSE;
      buf[8] = MOUSE_BTN_RIGHT;
      
      res = SetFeatureReport( dev, buf, 9 );
      if ( res < 0 )
      {
          if ( !bSuppressErrorSpew )
              printf( "SET_DIGITAL_MAPPINGS failed for controller %p\n", dev );
          return false;
      }
  #endif // ENABLE_MOUSE_MODE
      
      return true;
  }
  
  
  //---------------------------------------------------------------------------
  // Read from a Steam Controller
  //---------------------------------------------------------------------------
  static int ReadSteamController( hid_device *dev, uint8_t *pData, int nDataSize )
  {
      memset( pData, 0, nDataSize );
      pData[ 0 ] = BLE_REPORT_NUMBER; // hid_read will also overwrite this with the same value, 0x03
      return hid_read( dev, pData, nDataSize );
  }
  
  
  //---------------------------------------------------------------------------
  // Close a Steam Controller
  //---------------------------------------------------------------------------
  static void CloseSteamController( hid_device *dev )
  {
      // Switch the Steam Controller back to lizard mode so it works with the OS
      unsigned char buf[65];
      int nSettings = 0;
      
      // Reset digital button mappings
      memset( buf, 0, 65 );
      buf[1] = ID_SET_DEFAULT_DIGITAL_MAPPINGS;
      SetFeatureReport( dev, buf, 2 );
  
      // Reset the default settings
      memset( buf, 0, 65 );
      buf[1] = ID_LOAD_DEFAULT_SETTINGS;
      buf[2] = 0;
      SetFeatureReport( dev, buf, 3 );
  
      // Reset mouse mode for lizard mode
      memset( buf, 0, 65 );
      buf[1] = ID_SET_SETTINGS_VALUES;
      ADD_SETTING( SETTING_RIGHT_TRACKPAD_MODE, TRACKPAD_ABSOLUTE_MOUSE );
      buf[2] = nSettings*3;
      SetFeatureReport( dev, buf, 3+nSettings*3 );
  }
  
  
  //---------------------------------------------------------------------------
  // Scale and clamp values to a range
  //---------------------------------------------------------------------------
  static float RemapValClamped( float val, float A, float B, float C, float D)
  {
      if ( A == B )
      {
          return ( val - B ) >= 0.0f ? D : C;
      }
      else
      {
          float cVal = (val - A) / (B - A);
          cVal = clamp( cVal, 0.0f, 1.0f );
  
          return C + (D - C) * cVal;
      }
  }
  
  
  //---------------------------------------------------------------------------
  // Rotate the pad coordinates
  //---------------------------------------------------------------------------
  static void RotatePad( int *pX, int *pY, float flAngleInRad )
  {
      short int origX = *pX, origY = *pY;
  
      *pX = (int)( SDL_cosf( flAngleInRad ) * origX - SDL_sinf( flAngleInRad ) * origY );
      *pY = (int)( SDL_sinf( flAngleInRad ) * origX + SDL_cosf( flAngleInRad ) * origY );
  }
  static void RotatePadShort( short *pX, short *pY, float flAngleInRad )
  {
      short int origX = *pX, origY = *pY;
  
      *pX = (short)( SDL_cosf( flAngleInRad ) * origX - SDL_sinf( flAngleInRad ) * origY );
      *pY = (short)( SDL_sinf( flAngleInRad ) * origX + SDL_cosf( flAngleInRad ) * origY );
  }
  
  
  //---------------------------------------------------------------------------
  // Format the first part of the state packet
  //---------------------------------------------------------------------------
  static void FormatStatePacketUntilGyro( SteamControllerStateInternal_t *pState, ValveControllerStatePacket_t *pStatePacket )
  {
      memset(pState, 0, offsetof(SteamControllerStateInternal_t, sBatteryLevel));
  
      //pState->eControllerType = m_eControllerType;
      pState->eControllerType = 2; // k_eControllerType_SteamController;
      pState->unPacketNum = pStatePacket->unPacketNum;
  
      // We have a chunk of trigger data in the packet format here, so zero it out afterwards
      memcpy(&pState->ulButtons, &pStatePacket->ButtonTriggerData.ulButtons, 8);
      pState->ulButtons &= ~0xFFFF000000LL;
  
      // The firmware uses this bit to tell us what kind of data is packed into the left two axises
      if (pStatePacket->ButtonTriggerData.ulButtons & STEAM_LEFTPAD_FINGERDOWN_MASK)
      {
          // Finger-down bit not set; "left pad" is actually trackpad
          pState->sLeftPadX = pState->sPrevLeftPad[0] = pStatePacket->sLeftPadX;
          pState->sLeftPadY = pState->sPrevLeftPad[1] = pStatePacket->sLeftPadY;
  
          if (pStatePacket->ButtonTriggerData.ulButtons & STEAM_LEFTPAD_AND_JOYSTICK_MASK)
          {
              // The controller is interleaving both stick and pad data, both are active
              pState->sLeftStickX = pState->sPrevLeftStick[0];
              pState->sLeftStickY = pState->sPrevLeftStick[1];
          }
          else
          {
              // The stick is not active
              pState->sPrevLeftStick[0] = 0;
              pState->sPrevLeftStick[1] = 0;
          }
      }
      else
      {
          // Finger-down bit not set; "left pad" is actually joystick
  
          // XXX there's a firmware bug where sometimes padX is 0 and padY is a large number (acutally the battery voltage)
          // If that happens skip this packet and report last frames stick
  /*
          if ( m_eControllerType == k_eControllerType_SteamControllerV2 && pStatePacket->sLeftPadY > 900 )
          {
              pState->sLeftStickX = pState->sPrevLeftStick[0];
              pState->sLeftStickY = pState->sPrevLeftStick[1];
          }
          else
  */
          {
              pState->sPrevLeftStick[0] = pState->sLeftStickX = pStatePacket->sLeftPadX;
              pState->sPrevLeftStick[1] = pState->sLeftStickY = pStatePacket->sLeftPadY;
          }
  /*
          if (m_eControllerType == k_eControllerType_SteamControllerV2)
          {
              UpdateV2JoystickCap(&state);
          }
  */
  
          if (pStatePacket->ButtonTriggerData.ulButtons & STEAM_LEFTPAD_AND_JOYSTICK_MASK)
          {
              // The controller is interleaving both stick and pad data, both are active
              pState->sLeftPadX = pState->sPrevLeftPad[0];
              pState->sLeftPadY = pState->sPrevLeftPad[1];
          }
          else
          {
              // The trackpad is not active
              pState->sPrevLeftPad[0] = 0;
              pState->sPrevLeftPad[1] = 0;
  
              // Old controllers send trackpad click for joystick button when trackpad is not active
              if (pState->ulButtons & STEAM_BUTTON_LEFTPAD_CLICKED_MASK)
              {
                  pState->ulButtons &= ~STEAM_BUTTON_LEFTPAD_CLICKED_MASK;
                  pState->ulButtons |= STEAM_JOYSTICK_BUTTON_MASK;
              }
          }
      }
  
      // Fingerdown bit indicates if the packed left axis data was joystick or pad,
      // but if we are interleaving both, the left finger is definitely on the pad.
      if (pStatePacket->ButtonTriggerData.ulButtons & STEAM_LEFTPAD_AND_JOYSTICK_MASK)
          pState->ulButtons |= STEAM_LEFTPAD_FINGERDOWN_MASK;
  
      pState->sRightPadX = pStatePacket->sRightPadX;
      pState->sRightPadY = pStatePacket->sRightPadY;
  
      int nLeftPadX = pState->sLeftPadX;
      int nLeftPadY = pState->sLeftPadY;
      int nRightPadX = pState->sRightPadX;
      int nRightPadY = pState->sRightPadY;
  
      // 15 degrees in rad
      const float flRotationAngle = 0.261799f;
  
      RotatePad(&nLeftPadX, &nLeftPadY, -flRotationAngle);
      RotatePad(&nRightPadX, &nRightPadY, flRotationAngle);
  
      int nPadOffset;
      if (pState->ulButtons & STEAM_LEFTPAD_FINGERDOWN_MASK)
          nPadOffset = 1000;
      else
          nPadOffset = 0;
  
      pState->sLeftPadX = clamp(nLeftPadX + nPadOffset, SDL_MIN_SINT16, SDL_MAX_SINT16);
      pState->sLeftPadY = clamp(nLeftPadY + nPadOffset, SDL_MIN_SINT16, SDL_MAX_SINT16);
  
      nPadOffset = 0;
      if (pState->ulButtons & STEAM_RIGHTPAD_FINGERDOWN_MASK)
          nPadOffset = 1000;
      else
          nPadOffset = 0;
  
      pState->sRightPadX = clamp(nRightPadX + nPadOffset, SDL_MIN_SINT16, SDL_MAX_SINT16);
      pState->sRightPadY = clamp(nRightPadY + nPadOffset, SDL_MIN_SINT16, SDL_MAX_SINT16);
  
      pState->sTriggerL = (unsigned short)RemapValClamped( (pStatePacket->ButtonTriggerData.Triggers.nLeft << 7) | pStatePacket->ButtonTriggerData.Triggers.nLeft, 0, STEAMCONTROLLER_TRIGGER_MAX_ANALOG, 0, SDL_MAX_SINT16 );
      pState->sTriggerR = (unsigned short)RemapValClamped( (pStatePacket->ButtonTriggerData.Triggers.nRight << 7) | pStatePacket->ButtonTriggerData.Triggers.nRight, 0, STEAMCONTROLLER_TRIGGER_MAX_ANALOG, 0, SDL_MAX_SINT16 );
  }
  
  
  //---------------------------------------------------------------------------
  // Update Steam Controller state from a BLE data packet, returns true if it parsed data
  //---------------------------------------------------------------------------
  static bool UpdateBLESteamControllerState( const uint8_t *pData, int nDataSize, SteamControllerStateInternal_t *pState )
  {
      const float flRotationAngle = 0.261799f;
      uint32_t ucOptionDataMask;
  
      pState->unPacketNum++;
      ucOptionDataMask = ( *pData++ & 0xF0 );
      ucOptionDataMask |= (uint32_t)(*pData++) << 8;
      if ( ucOptionDataMask & k_EBLEButtonChunk1 )
      {
          memcpy( &pState->ulButtons, pData, 3 );
          pData += 3;
      }
      if ( ucOptionDataMask & k_EBLEButtonChunk2 )
      {
          // The middle 2 bytes of the button bits over the wire are triggers when over the wire and non-SC buttons in the internal controller state packet
          pState->sTriggerL = (unsigned short)RemapValClamped( ( pData[ 0 ] << 7 ) | pData[ 0 ], 0, STEAMCONTROLLER_TRIGGER_MAX_ANALOG, 0, SDL_MAX_SINT16 );
          pState->sTriggerR = (unsigned short)RemapValClamped( ( pData[ 1 ] << 7 ) | pData[ 1 ], 0, STEAMCONTROLLER_TRIGGER_MAX_ANALOG, 0, SDL_MAX_SINT16 );
          pData += 2;
      }
      if ( ucOptionDataMask & k_EBLEButtonChunk3 )
      {
          uint8_t *pButtonByte = (uint8_t *)&pState->ulButtons;
          pButtonByte[ 5 ] = *pData++;
          pButtonByte[ 6 ] = *pData++;
          pButtonByte[ 7 ] = *pData++;
      }
      if ( ucOptionDataMask & k_EBLELeftJoystickChunk )
      {
          // This doesn't handle any of the special headcrab stuff for raw joystick which is OK for now since that FW doesn't support
          // this protocol yet either
          int nLength = sizeof( pState->sLeftStickX ) + sizeof( pState->sLeftStickY );
          memcpy( &pState->sLeftStickX, pData, nLength );
          pData += nLength;
      }
      if ( ucOptionDataMask & k_EBLELeftTrackpadChunk )
      {
          int nLength = sizeof( pState->sLeftPadX ) + sizeof( pState->sLeftPadY );
          int nPadOffset;
          memcpy( &pState->sLeftPadX, pData, nLength );
          if ( pState->ulButtons & STEAM_LEFTPAD_FINGERDOWN_MASK )
              nPadOffset = 1000;
          else
              nPadOffset = 0;
  
          RotatePadShort( &pState->sLeftPadX, &pState->sLeftPadY, -flRotationAngle );
          pState->sLeftPadX = clamp( pState->sLeftPadX + nPadOffset, SDL_MIN_SINT16, SDL_MAX_SINT16 );
          pState->sLeftPadY = clamp( pState->sLeftPadY + nPadOffset, SDL_MIN_SINT16, SDL_MAX_SINT16 );
          pData += nLength;
      }
      if ( ucOptionDataMask & k_EBLERightTrackpadChunk )
      {
          int nLength = sizeof( pState->sRightPadX ) + sizeof( pState->sRightPadY );
          int nPadOffset = 0;
  
          memcpy( &pState->sRightPadX, pData, nLength );
  
          if ( pState->ulButtons & STEAM_RIGHTPAD_FINGERDOWN_MASK )
              nPadOffset = 1000;
          else
              nPadOffset = 0;
  
          RotatePadShort( &pState->sRightPadX, &pState->sRightPadY, flRotationAngle );
          pState->sRightPadX = clamp( pState->sRightPadX + nPadOffset, SDL_MIN_SINT16, SDL_MAX_SINT16 );
          pState->sRightPadY = clamp( pState->sRightPadY + nPadOffset, SDL_MIN_SINT16, SDL_MAX_SINT16 );
          pData += nLength;
      }
      if ( ucOptionDataMask & k_EBLEIMUAccelChunk )
      {
          int nLength = sizeof( pState->sAccelX ) + sizeof( pState->sAccelY ) + sizeof( pState->sAccelZ );
          memcpy( &pState->sAccelX, pData, nLength );
          pData += nLength;
      }
      if ( ucOptionDataMask & k_EBLEIMUGyroChunk )
      {
          int nLength = sizeof( pState->sAccelX ) + sizeof( pState->sAccelY ) + sizeof( pState->sAccelZ );
          memcpy( &pState->sGyroX, pData, nLength );
          pData += nLength;
      }
      if ( ucOptionDataMask & k_EBLEIMUQuatChunk )
      {
          int nLength = sizeof( pState->sGyroQuatW ) + sizeof( pState->sGyroQuatX ) + sizeof( pState->sGyroQuatY ) + sizeof( pState->sGyroQuatZ );
          memcpy( &pState->sGyroQuatW, pData, nLength );
          pData += nLength;
      }
      return true;
  }
  
  
  //---------------------------------------------------------------------------
  // Update Steam Controller state from a data packet, returns true if it parsed data
  //---------------------------------------------------------------------------
  static bool UpdateSteamControllerState( const uint8_t *pData, int nDataSize, SteamControllerStateInternal_t *pState )
  {
      ValveInReport_t *pInReport = (ValveInReport_t*)pData;
  
      if ( pInReport->header.unReportVersion != k_ValveInReportMsgVersion )
      {
          if ( ( pData[ 0 ] & 0x0F ) == k_EBLEReportState )
          {
              return UpdateBLESteamControllerState( pData, nDataSize, pState );
          }
          return false;
      }
  
      if ( ( pInReport->header.ucType != ID_CONTROLLER_STATE ) &&
           ( pInReport->header.ucType != ID_CONTROLLER_BLE_STATE ) )
      {
          return false;
      }
  
      if ( pInReport->header.ucType == ID_CONTROLLER_STATE )
      {
          ValveControllerStatePacket_t *pStatePacket = &pInReport->payload.controllerState;
  
          // No new data to process; indicate that we received a state packet, but otherwise do nothing.
          if ( pState->unPacketNum == pStatePacket->unPacketNum )
              return true;
  
          FormatStatePacketUntilGyro( pState, pStatePacket );
  
          pState->sAccelX = pStatePacket->sAccelX;
          pState->sAccelY = pStatePacket->sAccelY;
          pState->sAccelZ = pStatePacket->sAccelZ;
  
          pState->sGyroQuatW = pStatePacket->sGyroQuatW;
          pState->sGyroQuatX = pStatePacket->sGyroQuatX;
          pState->sGyroQuatY = pStatePacket->sGyroQuatY;
          pState->sGyroQuatZ = pStatePacket->sGyroQuatZ;
  
          pState->sGyroX = pStatePacket->sGyroX;
          pState->sGyroY = pStatePacket->sGyroY;
          pState->sGyroZ = pStatePacket->sGyroZ;
  
      }
      else if ( pInReport->header.ucType == ID_CONTROLLER_BLE_STATE )
      {
          ValveControllerBLEStatePacket_t *pBLEStatePacket = &pInReport->payload.controllerBLEState;
          ValveControllerStatePacket_t *pStatePacket = &pInReport->payload.controllerState;
  
          // No new data to process; indicate that we received a state packet, but otherwise do nothing.
          if ( pState->unPacketNum == pStatePacket->unPacketNum )
              return true;
  
          FormatStatePacketUntilGyro( pState, pStatePacket );
  
          switch ( pBLEStatePacket->ucGyroDataType )
          {
          case 1:
              pState->sGyroQuatW = (( float ) pBLEStatePacket->sGyro[0]);
              pState->sGyroQuatX = (( float ) pBLEStatePacket->sGyro[1]);
              pState->sGyroQuatY = (( float ) pBLEStatePacket->sGyro[2]);
              pState->sGyroQuatZ = (( float ) pBLEStatePacket->sGyro[3]);
              break;
  
          case 2:
              pState->sAccelX = pBLEStatePacket->sGyro[0];
              pState->sAccelY = pBLEStatePacket->sGyro[1];
              pState->sAccelZ = pBLEStatePacket->sGyro[2];
              break;
  
          case 3:
              pState->sGyroX = pBLEStatePacket->sGyro[0];
              pState->sGyroY = pBLEStatePacket->sGyro[1];
              pState->sGyroZ = pBLEStatePacket->sGyro[2];
              break;
  
          default:
              break;
          }
      }
  
      return true;
  }
  
  /*****************************************************************************************************/
  
  typedef struct {
      SteamControllerPacketAssembler m_assembler;
      SteamControllerStateInternal_t m_state;
      SteamControllerStateInternal_t m_last_state;
  } SDL_DriverSteam_Context;
  
  
  static SDL_bool
  HIDAPI_DriverSteam_IsSupportedDevice(const char *name, SDL_GameControllerType type, Uint16 vendor_id, Uint16 product_id, Uint16 version, int interface_number, int interface_class, int interface_subclass, int interface_protocol)
  {
      return SDL_IsJoystickSteamController(vendor_id, product_id);
  }
  
  static const char *
  HIDAPI_DriverSteam_GetDeviceName(Uint16 vendor_id, Uint16 product_id)
  {
      return "Steam Controller";
  }
  
  static SDL_bool
  HIDAPI_DriverSteam_InitDevice(SDL_HIDAPI_Device *device)
  {
      return HIDAPI_JoystickConnected(device, NULL, SDL_FALSE);
  }
  
  static int
  HIDAPI_DriverSteam_GetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id)
  {
      return -1;
  }
  
  static void
  HIDAPI_DriverSteam_SetDevicePlayerIndex(SDL_HIDAPI_Device *device, SDL_JoystickID instance_id, int player_index)
  {
  }
  
  static SDL_bool
  HIDAPI_DriverSteam_OpenJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
  {
      SDL_DriverSteam_Context *ctx;
  
      ctx = (SDL_DriverSteam_Context *)SDL_calloc(1, sizeof(*ctx));
      if (!ctx) {
          SDL_OutOfMemory();
          goto error;
      }
      device->context = ctx;
  
      device->dev = hid_open_path(device->path, 0);
      if (!device->dev) {
          SDL_SetError("Couldn't open %s", device->path);
          goto error;
      }
  
      if (!ResetSteamController(device->dev, false)) {
          goto error;
      }
  
      InitializeSteamControllerPacketAssembler(&ctx->m_assembler);
  
      /* Initialize the joystick capabilities */
      joystick->nbuttons = SDL_CONTROLLER_BUTTON_MAX;
      joystick->naxes = SDL_CONTROLLER_AXIS_MAX;
  
      return SDL_TRUE;
  
  error:
      if (device->dev) {
          hid_close(device->dev);
          device->dev = NULL;
      }
      if (device->context) {
          SDL_free(device->context);
          device->context = NULL;
      }
      return SDL_FALSE;
  }
  
  static int
  HIDAPI_DriverSteam_RumbleJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick, Uint16 low_frequency_rumble, Uint16 high_frequency_rumble)
  {
      /* You should use the full Steam Input API for rumble support */
      return SDL_Unsupported();
  }
  
  static SDL_bool
  HIDAPI_DriverSteam_UpdateDevice(SDL_HIDAPI_Device *device)
  {
      SDL_DriverSteam_Context *ctx = (SDL_DriverSteam_Context *)device->context;
      SDL_Joystick *joystick = NULL;
  
      if (device->num_joysticks > 0) {
          joystick = SDL_JoystickFromInstanceID(device->joysticks[0]);
      }
      if (!joystick) {
          return SDL_FALSE;
      }
  
      for (;;)
      {
          uint8_t data[128];
          int r, nPacketLength;
          const Uint8 *pPacket;
  
          r = ReadSteamController(device->dev, data, sizeof(data));
          if (r == 0)
          {
              break;
          }
  
          nPacketLength = 0;
          if (r > 0) {
              nPacketLength = WriteSegmentToSteamControllerPacketAssembler(&ctx->m_assembler, data, r);
          }
  
          pPacket = ctx->m_assembler.uBuffer;
  
          if (nPacketLength > 0 && UpdateSteamControllerState(pPacket, nPacketLength, &ctx->m_state)) {
              if (ctx->m_state.ulButtons != ctx->m_last_state.ulButtons) {
                  SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_A,
                      (ctx->m_state.ulButtons & STEAM_BUTTON_3_MASK) ? SDL_PRESSED : SDL_RELEASED);
  
                  SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_B,
                      (ctx->m_state.ulButtons & STEAM_BUTTON_1_MASK) ? SDL_PRESSED : SDL_RELEASED);
  
                  SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_X,
                      (ctx->m_state.ulButtons & STEAM_BUTTON_2_MASK) ? SDL_PRESSED : SDL_RELEASED);
  
                  SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_Y,
                      (ctx->m_state.ulButtons & STEAM_BUTTON_0_MASK) ? SDL_PRESSED : SDL_RELEASED);
  
                  SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_LEFTSHOULDER,
                      (ctx->m_state.ulButtons & STEAM_LEFT_BUMPER_MASK) ? SDL_PRESSED : SDL_RELEASED);
  
                  SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_RIGHTSHOULDER,
                      (ctx->m_state.ulButtons & STEAM_RIGHT_BUMPER_MASK) ? SDL_PRESSED : SDL_RELEASED);
  
                  SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_BACK,
                      (ctx->m_state.ulButtons & STEAM_BUTTON_MENU_MASK) ? SDL_PRESSED : SDL_RELEASED);
  
                  SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_START,
                      (ctx->m_state.ulButtons & STEAM_BUTTON_ESCAPE_MASK) ? SDL_PRESSED : SDL_RELEASED);
  
                  SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_GUIDE,
                      (ctx->m_state.ulButtons & STEAM_BUTTON_STEAM_MASK) ? SDL_PRESSED : SDL_RELEASED);
  
                  SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_LEFTSTICK,
                      (ctx->m_state.ulButtons & STEAM_JOYSTICK_BUTTON_MASK) ? SDL_PRESSED : SDL_RELEASED);
              }
              {
                  /* Minimum distance from center of pad to register a direction */
                  const int kPadDeadZone = 10000;
  
                  /* Pad coordinates are like math grid coordinates: negative is bottom left */
                  SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_DPAD_UP,
                      (ctx->m_state.sLeftPadY > kPadDeadZone) ? SDL_PRESSED : SDL_RELEASED);
  
                  SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_DPAD_DOWN,
                      (ctx->m_state.sLeftPadY < -kPadDeadZone) ? SDL_PRESSED : SDL_RELEASED);
  
                  SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_DPAD_LEFT,
                      (ctx->m_state.sLeftPadX < -kPadDeadZone) ? SDL_PRESSED : SDL_RELEASED);
  
                  SDL_PrivateJoystickButton(joystick, SDL_CONTROLLER_BUTTON_DPAD_RIGHT,
                      (ctx->m_state.sLeftPadX > kPadDeadZone) ? SDL_PRESSED : SDL_RELEASED);
              }
  
              SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_TRIGGERLEFT, (int)ctx->m_state.sTriggerL * 2 - 32768);
              SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_TRIGGERRIGHT, (int)ctx->m_state.sTriggerR * 2 - 32768);
  
              SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_LEFTX, ctx->m_state.sLeftStickX);
              SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_LEFTY, ~ctx->m_state.sLeftStickY);
              SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_RIGHTX, ctx->m_state.sRightPadX);
              SDL_PrivateJoystickAxis(joystick, SDL_CONTROLLER_AXIS_RIGHTY, ~ctx->m_state.sRightPadY);
  
              ctx->m_last_state = ctx->m_state;
          }
  
          if (r <= 0) {
              /* Failed to read from controller */
              HIDAPI_JoystickDisconnected(device, device->joysticks[0], SDL_FALSE);
              return SDL_FALSE;
          }
      }
      return SDL_TRUE;
  }
  
  static void
  HIDAPI_DriverSteam_CloseJoystick(SDL_HIDAPI_Device *device, SDL_Joystick *joystick)
  {
      CloseSteamController(device->dev);
      hid_close(device->dev);
      device->dev = NULL;
  
      SDL_free(device->context);
      device->context = NULL;
  }
  
  static void
  HIDAPI_DriverSteam_FreeDevice(SDL_HIDAPI_Device *device)
  {
  }
  
  SDL_HIDAPI_DeviceDriver SDL_HIDAPI_DriverSteam =
  {
      SDL_HINT_JOYSTICK_HIDAPI_STEAM,
      SDL_TRUE,
      HIDAPI_DriverSteam_IsSupportedDevice,
      HIDAPI_DriverSteam_GetDeviceName,
      HIDAPI_DriverSteam_InitDevice,
      HIDAPI_DriverSteam_GetDevicePlayerIndex,
      HIDAPI_DriverSteam_SetDevicePlayerIndex,
      HIDAPI_DriverSteam_UpdateDevice,
      HIDAPI_DriverSteam_OpenJoystick,
      HIDAPI_DriverSteam_RumbleJoystick,
      HIDAPI_DriverSteam_CloseJoystick,
      HIDAPI_DriverSteam_FreeDevice,
  	NULL
  };
  
  #endif /* SDL_JOYSTICK_HIDAPI_STEAM */
  
  #endif /* SDL_JOYSTICK_HIDAPI */
  
  /* vi: set ts=4 sw=4 expandtab: */
  

Download