// This file is provided under The MIT License as part of Steamworks.NET. // Copyright (c) 2013-2019 Riley Labrecque // Please see the included LICENSE.txt for additional information. // This file is automatically generated. // Changes to this file will be reverted when you update Steamworks.NET #if UNITY_ANDROID || UNITY_IOS || UNITY_TIZEN || UNITY_TVOS || UNITY_WEBGL || UNITY_WSA || UNITY_PS4 || UNITY_WII || UNITY_XBOXONE || UNITY_SWITCH #define DISABLESTEAMWORKS #endif #if !DISABLESTEAMWORKS using System.Runtime.InteropServices; using IntPtr = System.IntPtr; namespace Steamworks { public static class SteamInput { /// /// Init and Shutdown must be called when starting/ending use of this interface /// public static bool Init() { InteropHelp.TestIfAvailableClient(); return NativeMethods.ISteamInput_Init(CSteamAPIContext.GetSteamInput()); } public static bool Shutdown() { InteropHelp.TestIfAvailableClient(); return NativeMethods.ISteamInput_Shutdown(CSteamAPIContext.GetSteamInput()); } /// /// Synchronize API state with the latest Steam Controller inputs available. This /// is performed automatically by SteamAPI_RunCallbacks, but for the absolute lowest /// possible latency, you call this directly before reading controller state. This must /// be called from somewhere before GetConnectedControllers will return any handles /// public static void RunFrame() { InteropHelp.TestIfAvailableClient(); NativeMethods.ISteamInput_RunFrame(CSteamAPIContext.GetSteamInput()); } /// /// Enumerate currently connected Steam Input enabled devices - developers can opt in controller by type (ex: Xbox/Playstation/etc) via /// the Steam Input settings in the Steamworks site or users can opt-in in their controller settings in Steam. /// handlesOut should point to a STEAM_INPUT_MAX_COUNT sized array of InputHandle_t handles /// Returns the number of handles written to handlesOut /// public static int GetConnectedControllers(InputHandle_t[] handlesOut) { InteropHelp.TestIfAvailableClient(); if (handlesOut != null && handlesOut.Length != Constants.STEAM_INPUT_MAX_COUNT) { throw new System.ArgumentException("handlesOut must be the same size as Constants.STEAM_INPUT_MAX_COUNT!"); } return NativeMethods.ISteamInput_GetConnectedControllers(CSteamAPIContext.GetSteamInput(), handlesOut); } /// /// ----------------------------------------------------------------------------- /// 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. /// public static InputActionSetHandle_t GetActionSetHandle(string pszActionSetName) { InteropHelp.TestIfAvailableClient(); using (var pszActionSetName2 = new InteropHelp.UTF8StringHandle(pszActionSetName)) { return (InputActionSetHandle_t)NativeMethods.ISteamInput_GetActionSetHandle(CSteamAPIContext.GetSteamInput(), pszActionSetName2); } } /// /// 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. /// public static void ActivateActionSet(InputHandle_t inputHandle, InputActionSetHandle_t actionSetHandle) { InteropHelp.TestIfAvailableClient(); NativeMethods.ISteamInput_ActivateActionSet(CSteamAPIContext.GetSteamInput(), inputHandle, actionSetHandle); } public static InputActionSetHandle_t GetCurrentActionSet(InputHandle_t inputHandle) { InteropHelp.TestIfAvailableClient(); return (InputActionSetHandle_t)NativeMethods.ISteamInput_GetCurrentActionSet(CSteamAPIContext.GetSteamInput(), inputHandle); } /// /// ACTION SET LAYERS /// public static void ActivateActionSetLayer(InputHandle_t inputHandle, InputActionSetHandle_t actionSetLayerHandle) { InteropHelp.TestIfAvailableClient(); NativeMethods.ISteamInput_ActivateActionSetLayer(CSteamAPIContext.GetSteamInput(), inputHandle, actionSetLayerHandle); } public static void DeactivateActionSetLayer(InputHandle_t inputHandle, InputActionSetHandle_t actionSetLayerHandle) { InteropHelp.TestIfAvailableClient(); NativeMethods.ISteamInput_DeactivateActionSetLayer(CSteamAPIContext.GetSteamInput(), inputHandle, actionSetLayerHandle); } public static void DeactivateAllActionSetLayers(InputHandle_t inputHandle) { InteropHelp.TestIfAvailableClient(); NativeMethods.ISteamInput_DeactivateAllActionSetLayers(CSteamAPIContext.GetSteamInput(), inputHandle); } /// /// Enumerate currently active layers. /// handlesOut should point to a STEAM_INPUT_MAX_ACTIVE_LAYERS sized array of ControllerActionSetHandle_t handles /// Returns the number of handles written to handlesOut /// public static int GetActiveActionSetLayers(InputHandle_t inputHandle, InputActionSetHandle_t[] handlesOut) { InteropHelp.TestIfAvailableClient(); if (handlesOut != null && handlesOut.Length != Constants.STEAM_INPUT_MAX_ACTIVE_LAYERS) { throw new System.ArgumentException("handlesOut must be the same size as Constants.STEAM_INPUT_MAX_ACTIVE_LAYERS!"); } return NativeMethods.ISteamInput_GetActiveActionSetLayers(CSteamAPIContext.GetSteamInput(), inputHandle, handlesOut); } /// /// ----------------------------------------------------------------------------- /// ACTIONS /// ----------------------------------------------------------------------------- /// Lookup the handle for a digital action. Best to do this once on startup, and store the handles for all future API calls. /// public static InputDigitalActionHandle_t GetDigitalActionHandle(string pszActionName) { InteropHelp.TestIfAvailableClient(); using (var pszActionName2 = new InteropHelp.UTF8StringHandle(pszActionName)) { return (InputDigitalActionHandle_t)NativeMethods.ISteamInput_GetDigitalActionHandle(CSteamAPIContext.GetSteamInput(), pszActionName2); } } /// /// Returns the current state of the supplied digital game action /// public static InputDigitalActionData_t GetDigitalActionData(InputHandle_t inputHandle, InputDigitalActionHandle_t digitalActionHandle) { InteropHelp.TestIfAvailableClient(); return NativeMethods.ISteamInput_GetDigitalActionData(CSteamAPIContext.GetSteamInput(), inputHandle, digitalActionHandle); } /// /// 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_INPUT_MAX_ORIGINS sized array of EInputActionOrigin handles. The EInputActionOrigin enum will get extended as support for new controller controllers gets added to /// the Steam client and will exceed the values from this header, please check bounds if you are using a look up table. /// public static int GetDigitalActionOrigins(InputHandle_t inputHandle, InputActionSetHandle_t actionSetHandle, InputDigitalActionHandle_t digitalActionHandle, EInputActionOrigin[] originsOut) { InteropHelp.TestIfAvailableClient(); if (originsOut != null && originsOut.Length != Constants.STEAM_INPUT_MAX_ORIGINS) { throw new System.ArgumentException("originsOut must be the same size as Constants.STEAM_INPUT_MAX_ORIGINS!"); } return NativeMethods.ISteamInput_GetDigitalActionOrigins(CSteamAPIContext.GetSteamInput(), inputHandle, actionSetHandle, digitalActionHandle, originsOut); } /// /// Lookup the handle for an analog action. Best to do this once on startup, and store the handles for all future API calls. /// public static InputAnalogActionHandle_t GetAnalogActionHandle(string pszActionName) { InteropHelp.TestIfAvailableClient(); using (var pszActionName2 = new InteropHelp.UTF8StringHandle(pszActionName)) { return (InputAnalogActionHandle_t)NativeMethods.ISteamInput_GetAnalogActionHandle(CSteamAPIContext.GetSteamInput(), pszActionName2); } } /// /// Returns the current state of these supplied analog game action /// public static InputAnalogActionData_t GetAnalogActionData(InputHandle_t inputHandle, InputAnalogActionHandle_t analogActionHandle) { InteropHelp.TestIfAvailableClient(); return NativeMethods.ISteamInput_GetAnalogActionData(CSteamAPIContext.GetSteamInput(), inputHandle, analogActionHandle); } /// /// 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_INPUT_MAX_ORIGINS sized array of EInputActionOrigin handles. The EInputActionOrigin enum will get extended as support for new controller controllers gets added to /// the Steam client and will exceed the values from this header, please check bounds if you are using a look up table. /// public static int GetAnalogActionOrigins(InputHandle_t inputHandle, InputActionSetHandle_t actionSetHandle, InputAnalogActionHandle_t analogActionHandle, EInputActionOrigin[] originsOut) { InteropHelp.TestIfAvailableClient(); if (originsOut != null && originsOut.Length != Constants.STEAM_INPUT_MAX_ORIGINS) { throw new System.ArgumentException("originsOut must be the same size as Constants.STEAM_INPUT_MAX_ORIGINS!"); } return NativeMethods.ISteamInput_GetAnalogActionOrigins(CSteamAPIContext.GetSteamInput(), inputHandle, actionSetHandle, analogActionHandle, originsOut); } /// /// Get a local path to art for on-screen glyph for a particular origin /// public static string GetGlyphForActionOrigin(EInputActionOrigin eOrigin) { InteropHelp.TestIfAvailableClient(); return InteropHelp.PtrToStringUTF8(NativeMethods.ISteamInput_GetGlyphForActionOrigin(CSteamAPIContext.GetSteamInput(), eOrigin)); } /// /// Returns a localized string (from Steam's language setting) for the specified origin. /// public static string GetStringForActionOrigin(EInputActionOrigin eOrigin) { InteropHelp.TestIfAvailableClient(); return InteropHelp.PtrToStringUTF8(NativeMethods.ISteamInput_GetStringForActionOrigin(CSteamAPIContext.GetSteamInput(), eOrigin)); } /// /// Stop analog momentum for the action if it is a mouse action in trackball mode /// public static void StopAnalogActionMomentum(InputHandle_t inputHandle, InputAnalogActionHandle_t eAction) { InteropHelp.TestIfAvailableClient(); NativeMethods.ISteamInput_StopAnalogActionMomentum(CSteamAPIContext.GetSteamInput(), inputHandle, eAction); } /// /// Returns raw motion data from the specified device /// public static InputMotionData_t GetMotionData(InputHandle_t inputHandle) { InteropHelp.TestIfAvailableClient(); return NativeMethods.ISteamInput_GetMotionData(CSteamAPIContext.GetSteamInput(), inputHandle); } /// /// ----------------------------------------------------------------------------- /// OUTPUTS /// ----------------------------------------------------------------------------- /// Trigger a vibration event on supported controllers - Steam will translate these commands into haptic pulses for Steam Controllers /// public static void TriggerVibration(InputHandle_t inputHandle, ushort usLeftSpeed, ushort usRightSpeed) { InteropHelp.TestIfAvailableClient(); NativeMethods.ISteamInput_TriggerVibration(CSteamAPIContext.GetSteamInput(), inputHandle, usLeftSpeed, usRightSpeed); } /// /// Set the controller LED color on supported controllers. nFlags is a bitmask of values from ESteamInputLEDFlag - 0 will default to setting a color. Steam will handle /// the behavior on exit of your program so you don't need to try restore the default as you are shutting down /// public static void SetLEDColor(InputHandle_t inputHandle, byte nColorR, byte nColorG, byte nColorB, uint nFlags) { InteropHelp.TestIfAvailableClient(); NativeMethods.ISteamInput_SetLEDColor(CSteamAPIContext.GetSteamInput(), inputHandle, nColorR, nColorG, nColorB, nFlags); } /// /// Trigger a haptic pulse on a Steam Controller - if you are approximating rumble you may want to use TriggerVibration instead. /// Good uses for Haptic pulses include chimes, noises, or directional gameplay feedback (taking damage, footstep locations, etc). /// public static void TriggerHapticPulse(InputHandle_t inputHandle, ESteamControllerPad eTargetPad, ushort usDurationMicroSec) { InteropHelp.TestIfAvailableClient(); NativeMethods.ISteamInput_TriggerHapticPulse(CSteamAPIContext.GetSteamInput(), inputHandle, eTargetPad, usDurationMicroSec); } /// /// Trigger a haptic pulse with a duty cycle of usDurationMicroSec / usOffMicroSec, unRepeat times. If you are approximating rumble you may want to use TriggerVibration instead. /// nFlags is currently unused and reserved for future use. /// public static void TriggerRepeatedHapticPulse(InputHandle_t inputHandle, ESteamControllerPad eTargetPad, ushort usDurationMicroSec, ushort usOffMicroSec, ushort unRepeat, uint nFlags) { InteropHelp.TestIfAvailableClient(); NativeMethods.ISteamInput_TriggerRepeatedHapticPulse(CSteamAPIContext.GetSteamInput(), inputHandle, eTargetPad, usDurationMicroSec, usOffMicroSec, unRepeat, nFlags); } /// /// ----------------------------------------------------------------------------- /// Utility functions availible without using the rest of Steam Input API /// ----------------------------------------------------------------------------- /// Invokes the Steam overlay and brings up the binding screen if the user is using Big Picture Mode /// If the user is not in Big Picture Mode it will open up the binding in a new window /// public static bool ShowBindingPanel(InputHandle_t inputHandle) { InteropHelp.TestIfAvailableClient(); return NativeMethods.ISteamInput_ShowBindingPanel(CSteamAPIContext.GetSteamInput(), inputHandle); } /// /// Returns the input type for a particular handle /// public static ESteamInputType GetInputTypeForHandle(InputHandle_t inputHandle) { InteropHelp.TestIfAvailableClient(); return NativeMethods.ISteamInput_GetInputTypeForHandle(CSteamAPIContext.GetSteamInput(), inputHandle); } /// /// Returns the associated controller handle for the specified emulated gamepad - can be used with the above 2 functions /// to identify controllers presented to your game over Xinput. Returns 0 if the Xinput index isn't associated with Steam Input /// public static InputHandle_t GetControllerForGamepadIndex(int nIndex) { InteropHelp.TestIfAvailableClient(); return (InputHandle_t)NativeMethods.ISteamInput_GetControllerForGamepadIndex(CSteamAPIContext.GetSteamInput(), nIndex); } /// /// Returns the associated gamepad index for the specified controller, if emulating a gamepad or -1 if not associated with an Xinput index /// public static int GetGamepadIndexForController(InputHandle_t ulinputHandle) { InteropHelp.TestIfAvailableClient(); return NativeMethods.ISteamInput_GetGamepadIndexForController(CSteamAPIContext.GetSteamInput(), ulinputHandle); } /// /// Returns a localized string (from Steam's language setting) for the specified Xbox controller origin. /// public static string GetStringForXboxOrigin(EXboxOrigin eOrigin) { InteropHelp.TestIfAvailableClient(); return InteropHelp.PtrToStringUTF8(NativeMethods.ISteamInput_GetStringForXboxOrigin(CSteamAPIContext.GetSteamInput(), eOrigin)); } /// /// Get a local path to art for on-screen glyph for a particular Xbox controller origin /// public static string GetGlyphForXboxOrigin(EXboxOrigin eOrigin) { InteropHelp.TestIfAvailableClient(); return InteropHelp.PtrToStringUTF8(NativeMethods.ISteamInput_GetGlyphForXboxOrigin(CSteamAPIContext.GetSteamInput(), eOrigin)); } /// /// Get the equivalent ActionOrigin for a given Xbox controller origin this can be chained with GetGlyphForActionOrigin to provide future proof glyphs for /// non-Steam Input API action games. Note - this only translates the buttons directly and doesn't take into account any remapping a user has made in their configuration /// public static EInputActionOrigin GetActionOriginFromXboxOrigin(InputHandle_t inputHandle, EXboxOrigin eOrigin) { InteropHelp.TestIfAvailableClient(); return NativeMethods.ISteamInput_GetActionOriginFromXboxOrigin(CSteamAPIContext.GetSteamInput(), inputHandle, eOrigin); } /// /// Convert an origin to another controller type - for inputs not present on the other controller type this will return k_EInputActionOrigin_None /// When a new input type is added you will be able to pass in k_ESteamInputType_Unknown and the closest origin that your version of the SDK recognized will be returned /// ex: if a Playstation 5 controller was released this function would return Playstation 4 origins. /// public static EInputActionOrigin TranslateActionOrigin(ESteamInputType eDestinationInputType, EInputActionOrigin eSourceOrigin) { InteropHelp.TestIfAvailableClient(); return NativeMethods.ISteamInput_TranslateActionOrigin(CSteamAPIContext.GetSteamInput(), eDestinationInputType, eSourceOrigin); } /// /// Get the binding revision for a given device. Returns false if the handle was not valid or if a mapping is not yet loaded for the device /// public static bool GetDeviceBindingRevision(InputHandle_t inputHandle, out int pMajor, out int pMinor) { InteropHelp.TestIfAvailableClient(); return NativeMethods.ISteamInput_GetDeviceBindingRevision(CSteamAPIContext.GetSteamInput(), inputHandle, out pMajor, out pMinor); } /// /// Get the Steam Remote Play session ID associated with a device, or 0 if there is no session associated with it /// See isteamremoteplay.h for more information on Steam Remote Play sessions /// public static uint GetRemotePlaySessionID(InputHandle_t inputHandle) { InteropHelp.TestIfAvailableClient(); return NativeMethods.ISteamInput_GetRemotePlaySessionID(CSteamAPIContext.GetSteamInput(), inputHandle); } } } #endif // !DISABLESTEAMWORKS