//====== Copyright 1996-2013, Valve Corporation, All rights reserved. ======= // // Purpose: interface to valve controller // //============================================================================= #ifndef ISTEAMCONTROLLER_H #define ISTEAMCONTROLLER_H #ifdef _WIN32 #pragma once #endif #include "isteamclient.h" #define STEAM_CONTROLLER_MAX_COUNT 16 #define STEAM_CONTROLLER_MAX_ANALOG_ACTIONS 16 #define STEAM_CONTROLLER_MAX_DIGITAL_ACTIONS 32 #define STEAM_CONTROLLER_MAX_ORIGINS 8 // When sending an option to a specific controller handle, you can send to all controllers via this command #define STEAM_CONTROLLER_HANDLE_ALL_CONTROLLERS UINT64_MAX #define STEAM_CONTROLLER_MIN_ANALOG_ACTION_DATA -1.0f #define STEAM_CONTROLLER_MAX_ANALOG_ACTION_DATA 1.0f enum ESteamControllerPad { k_ESteamControllerPad_Left, k_ESteamControllerPad_Right }; enum EControllerSource { k_EControllerSource_None, k_EControllerSource_LeftTrackpad, k_EControllerSource_RightTrackpad, k_EControllerSource_Joystick, k_EControllerSource_ABXY, k_EControllerSource_Switch, k_EControllerSource_LeftTrigger, k_EControllerSource_RightTrigger, k_EControllerSource_Gyro }; enum EControllerSourceMode { k_EControllerSourceMode_None, k_EControllerSourceMode_Dpad, k_EControllerSourceMode_Buttons, k_EControllerSourceMode_FourButtons, k_EControllerSourceMode_AbsoluteMouse, k_EControllerSourceMode_RelativeMouse, k_EControllerSourceMode_JoystickMove, k_EControllerSourceMode_JoystickCamera, k_EControllerSourceMode_ScrollWheel, k_EControllerSourceMode_Trigger, k_EControllerSourceMode_TouchMenu }; enum EControllerActionOrigin { k_EControllerActionOrigin_None, k_EControllerActionOrigin_A, k_EControllerActionOrigin_B, k_EControllerActionOrigin_X, k_EControllerActionOrigin_Y, k_EControllerActionOrigin_LeftBumper, k_EControllerActionOrigin_RightBumper, k_EControllerActionOrigin_LeftGrip, k_EControllerActionOrigin_RightGrip, k_EControllerActionOrigin_Start, k_EControllerActionOrigin_Back, k_EControllerActionOrigin_LeftPad_Touch, k_EControllerActionOrigin_LeftPad_Swipe, k_EControllerActionOrigin_LeftPad_Click, k_EControllerActionOrigin_LeftPad_DPadNorth, k_EControllerActionOrigin_LeftPad_DPadSouth, k_EControllerActionOrigin_LeftPad_DPadWest, k_EControllerActionOrigin_LeftPad_DPadEast, k_EControllerActionOrigin_RightPad_Touch, k_EControllerActionOrigin_RightPad_Swipe, k_EControllerActionOrigin_RightPad_Click, k_EControllerActionOrigin_RightPad_DPadNorth, k_EControllerActionOrigin_RightPad_DPadSouth, k_EControllerActionOrigin_RightPad_DPadWest, k_EControllerActionOrigin_RightPad_DPadEast, k_EControllerActionOrigin_LeftTrigger_Pull, k_EControllerActionOrigin_LeftTrigger_Click, k_EControllerActionOrigin_RightTrigger_Pull, k_EControllerActionOrigin_RightTrigger_Click, k_EControllerActionOrigin_LeftStick_Move, k_EControllerActionOrigin_LeftStick_Click, k_EControllerActionOrigin_LeftStick_DPadNorth, k_EControllerActionOrigin_LeftStick_DPadSouth, k_EControllerActionOrigin_LeftStick_DPadWest, k_EControllerActionOrigin_LeftStick_DPadEast, k_EControllerActionOrigin_Gyro_Move, k_EControllerActionOrigin_Gyro_Pitch, k_EControllerActionOrigin_Gyro_Yaw, k_EControllerActionOrigin_Gyro_Roll, k_EControllerActionOrigin_Count }; // ControllerHandle_t is used to refer to a specific controller. // This handle will consistently identify a controller, even if it is disconnected and re-connected typedef uint64 ControllerHandle_t; // These handles are used to refer to a specific in-game action or action set // All action handles should be queried during initialization for performance reasons typedef uint64 ControllerActionSetHandle_t; typedef uint64 ControllerDigitalActionHandle_t; typedef uint64 ControllerAnalogActionHandle_t; #pragma pack( push, 1 ) struct ControllerAnalogActionData_t { // Type of data coming from this action, this will match what got specified in the action set EControllerSourceMode eMode; // The current state of this action; will be delta updates for mouse actions float x, y; // Whether or not this action is currently available to be bound in the active action set bool bActive; }; struct ControllerDigitalActionData_t { // The current state of this action; will be true if currently pressed bool bState; // Whether or not this action is currently available to be bound in the active action set bool bActive; }; #pragma pack( pop ) //----------------------------------------------------------------------------- // Purpose: Native Steam controller support API //----------------------------------------------------------------------------- class ISteamController { public: // Init and Shutdown must be called when starting/ending use of this interface virtual bool Init() = 0; virtual bool Shutdown() = 0; // Pump callback/callresult events // Note: SteamAPI_RunCallbacks will do this for you, so you should never need to call this directly. virtual void RunFrame() = 0; // Enumerate currently connected controllers // handlesOut should point to a STEAM_CONTROLLER_MAX_COUNT sized array of ControllerHandle_t handles // Returns the number of handles written to handlesOut virtual int GetConnectedControllers( ControllerHandle_t *handlesOut ) = 0; // Invokes the Steam overlay and brings up the binding screen // Returns false is overlay is disabled / unavailable, or the user is not in Big Picture mode virtual bool ShowBindingPanel( ControllerHandle_t controllerHandle ) = 0; // ACTION SETS // Lookup the handle for an Action Set. Best to do this once on startup, and store the handles for all future API calls. virtual ControllerActionSetHandle_t GetActionSetHandle( const char *pszActionSetName ) = 0; // Reconfigure the controller to use the specified action set (ie 'Menu', 'Walk' or 'Drive') // This is cheap, and can be safely called repeatedly. It's often easier to repeatedly call it in // your state loops, instead of trying to place it in all of your state transitions. virtual void ActivateActionSet( ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle ) = 0; virtual ControllerActionSetHandle_t GetCurrentActionSet( ControllerHandle_t controllerHandle ) = 0; // ACTIONS // Lookup the handle for a digital action. Best to do this once on startup, and store the handles for all future API calls. virtual ControllerDigitalActionHandle_t GetDigitalActionHandle( const char *pszActionName ) = 0; // Returns the current state of the supplied digital game action virtual ControllerDigitalActionData_t GetDigitalActionData( ControllerHandle_t controllerHandle, ControllerDigitalActionHandle_t digitalActionHandle ) = 0; // Get the origin(s) for a digital action within an action set. Returns the number of origins supplied in originsOut. Use this to display the appropriate on-screen prompt for the action. // originsOut should point to a STEAM_CONTROLLER_MAX_ORIGINS sized array of EControllerActionOrigin handles virtual int GetDigitalActionOrigins( ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerDigitalActionHandle_t digitalActionHandle, EControllerActionOrigin *originsOut ) = 0; // Lookup the handle for an analog action. Best to do this once on startup, and store the handles for all future API calls. virtual ControllerAnalogActionHandle_t GetAnalogActionHandle( const char *pszActionName ) = 0; // Returns the current state of these supplied analog game action virtual ControllerAnalogActionData_t GetAnalogActionData( ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t analogActionHandle ) = 0; // Get the origin(s) for an analog action within an action set. Returns the number of origins supplied in originsOut. Use this to display the appropriate on-screen prompt for the action. // originsOut should point to a STEAM_CONTROLLER_MAX_ORIGINS sized array of EControllerActionOrigin handles virtual int GetAnalogActionOrigins( ControllerHandle_t controllerHandle, ControllerActionSetHandle_t actionSetHandle, ControllerAnalogActionHandle_t analogActionHandle, EControllerActionOrigin *originsOut ) = 0; virtual void StopAnalogActionMomentum( ControllerHandle_t controllerHandle, ControllerAnalogActionHandle_t eAction ) = 0; // Trigger a haptic pulse on a controller virtual void TriggerHapticPulse( ControllerHandle_t controllerHandle, ESteamControllerPad eTargetPad, unsigned short usDurationMicroSec ) = 0; }; #define STEAMCONTROLLER_INTERFACE_VERSION "SteamController003" #endif // ISTEAMCONTROLLER_H