// This file is provided under The MIT License as part of Steamworks.NET.
// Copyright (c) 2013-2022 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_STANDALONE_WIN || UNITY_STANDALONE_LINUX || UNITY_STANDALONE_OSX || STEAMWORKS_WIN || STEAMWORKS_LIN_OSX)
#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.
/// if bExplicitlyCallRunFrame is called then you will need to manually call RunFrame
/// each frame, otherwise Steam Input will updated when SteamAPI_RunCallbacks() is called
///
public static bool Init(bool bExplicitlyCallRunFrame) {
InteropHelp.TestIfAvailableClient();
return NativeMethods.ISteamInput_Init(CSteamAPIContext.GetSteamInput(), bExplicitlyCallRunFrame);
}
public static bool Shutdown() {
InteropHelp.TestIfAvailableClient();
return NativeMethods.ISteamInput_Shutdown(CSteamAPIContext.GetSteamInput());
}
///
/// Set the absolute path to the Input Action Manifest file containing the in-game actions
/// and file paths to the official configurations. Used in games that bundle Steam Input
/// configurations inside of the game depot instead of using the Steam Workshop
///
public static bool SetInputActionManifestFilePath(string pchInputActionManifestAbsolutePath) {
InteropHelp.TestIfAvailableClient();
using (var pchInputActionManifestAbsolutePath2 = new InteropHelp.UTF8StringHandle(pchInputActionManifestAbsolutePath)) {
return NativeMethods.ISteamInput_SetInputActionManifestFilePath(CSteamAPIContext.GetSteamInput(), pchInputActionManifestAbsolutePath2);
}
}
///
/// Synchronize API state with the latest Steam Input action data available. This
/// is performed automatically by SteamAPI_RunCallbacks, but for the absolute lowest
/// possible latency, you call this directly before reading controller state.
/// Note: This must be called from somewhere before GetConnectedControllers will
/// return any handles
///
public static void RunFrame(bool bReservedValue = true) {
InteropHelp.TestIfAvailableClient();
NativeMethods.ISteamInput_RunFrame(CSteamAPIContext.GetSteamInput(), bReservedValue);
}
///
/// Waits on an IPC event from Steam sent when there is new data to be fetched from
/// the data drop. Returns true when data was recievied before the timeout expires.
/// Useful for games with a dedicated input thread
///
public static bool BWaitForData(bool bWaitForever, uint unTimeout) {
InteropHelp.TestIfAvailableClient();
return NativeMethods.ISteamInput_BWaitForData(CSteamAPIContext.GetSteamInput(), bWaitForever, unTimeout);
}
///
/// Returns true if new data has been received since the last time action data was accessed
/// via GetDigitalActionData or GetAnalogActionData. The game will still need to call
/// SteamInput()->RunFrame() or SteamAPI_RunCallbacks() before this to update the data stream
///
public static bool BNewDataAvailable() {
InteropHelp.TestIfAvailableClient();
return NativeMethods.ISteamInput_BNewDataAvailable(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);
}
///
/// -----------------------------------------------------------------------------
/// CALLBACKS
/// -----------------------------------------------------------------------------
/// Controller configuration loaded - these callbacks will always fire if you have
/// a handler. Note: this is called within either SteamInput()->RunFrame or by SteamAPI_RunCallbacks
/// Enable SteamInputDeviceConnected_t and SteamInputDeviceDisconnected_t callbacks.
/// Each controller that is already connected will generate a device connected
/// callback when you enable them
///
public static void EnableDeviceCallbacks() {
InteropHelp.TestIfAvailableClient();
NativeMethods.ISteamInput_EnableDeviceCallbacks(CSteamAPIContext.GetSteamInput());
}
///
/// Controller Connected - provides info about a single newly connected controller
/// Note: this is called within either SteamInput()->RunFrame or by SteamAPI_RunCallbacks
/// Controller Disconnected - provides info about a single disconnected controller
/// Note: this is called within either SteamInput()->RunFrame or by SteamAPI_RunCallbacks
/// Controllers using Gamepad emulation (XInput, DirectInput, etc) will be seated in the order that
/// input is sent by the device. This callback will fire on first input for each device and when the
/// a user has manually changed the order via the Steam overlay. This also has the device type info
/// so that you can change out glyph sets without making additional API calls
/// Enable SteamInputActionEvent_t callbacks. Directly calls your callback function
/// for lower latency than standard Steam callbacks. Supports one callback at a time.
/// Note: this is called within either SteamInput()->RunFrame or by SteamAPI_RunCallbacks
///
public static void EnableActionEventCallbacks(SteamInputActionEventCallbackPointer pCallback) {
InteropHelp.TestIfAvailableClient();
NativeMethods.ISteamInput_EnableActionEventCallbacks(CSteamAPIContext.GetSteamInput(), pCallback);
}
///
/// -----------------------------------------------------------------------------
/// 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 InputActionSetHandle_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);
}
///
/// Returns a localized string (from Steam's language setting) for the user-facing action name corresponding to the specified handle
///
public static string GetStringForDigitalActionName(InputDigitalActionHandle_t eActionHandle) {
InteropHelp.TestIfAvailableClient();
return InteropHelp.PtrToStringUTF8(NativeMethods.ISteamInput_GetStringForDigitalActionName(CSteamAPIContext.GetSteamInput(), eActionHandle));
}
///
/// 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 a PNG file for the provided origin's glyph.
///
public static string GetGlyphPNGForActionOrigin(EInputActionOrigin eOrigin, ESteamInputGlyphSize eSize, uint unFlags) {
InteropHelp.TestIfAvailableClient();
return InteropHelp.PtrToStringUTF8(NativeMethods.ISteamInput_GetGlyphPNGForActionOrigin(CSteamAPIContext.GetSteamInput(), eOrigin, eSize, unFlags));
}
///
/// Get a local path to a SVG file for the provided origin's glyph.
///
public static string GetGlyphSVGForActionOrigin(EInputActionOrigin eOrigin, uint unFlags) {
InteropHelp.TestIfAvailableClient();
return InteropHelp.PtrToStringUTF8(NativeMethods.ISteamInput_GetGlyphSVGForActionOrigin(CSteamAPIContext.GetSteamInput(), eOrigin, unFlags));
}
///
/// Get a local path to an older, Big Picture Mode-style PNG file for a particular origin
///
public static string GetGlyphForActionOrigin_Legacy(EInputActionOrigin eOrigin) {
InteropHelp.TestIfAvailableClient();
return InteropHelp.PtrToStringUTF8(NativeMethods.ISteamInput_GetGlyphForActionOrigin_Legacy(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));
}
///
/// Returns a localized string (from Steam's language setting) for the user-facing action name corresponding to the specified handle
///
public static string GetStringForAnalogActionName(InputAnalogActionHandle_t eActionHandle) {
InteropHelp.TestIfAvailableClient();
return InteropHelp.PtrToStringUTF8(NativeMethods.ISteamInput_GetStringForAnalogActionName(CSteamAPIContext.GetSteamInput(), eActionHandle));
}
///
/// 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);
}
///
/// Trigger a vibration event on supported controllers including Xbox trigger impulse rumble - Steam will translate these commands into haptic pulses for Steam Controllers
///
public static void TriggerVibrationExtended(InputHandle_t inputHandle, ushort usLeftSpeed, ushort usRightSpeed, ushort usLeftTriggerSpeed, ushort usRightTriggerSpeed) {
InteropHelp.TestIfAvailableClient();
NativeMethods.ISteamInput_TriggerVibrationExtended(CSteamAPIContext.GetSteamInput(), inputHandle, usLeftSpeed, usRightSpeed, usLeftTriggerSpeed, usRightTriggerSpeed);
}
///
/// Send a haptic pulse, works on Steam Deck and Steam Controller devices
///
public static void TriggerSimpleHapticEvent(InputHandle_t inputHandle, EControllerHapticLocation eHapticLocation, byte nIntensity, char nGainDB, byte nOtherIntensity, char nOtherGainDB) {
InteropHelp.TestIfAvailableClient();
NativeMethods.ISteamInput_TriggerSimpleHapticEvent(CSteamAPIContext.GetSteamInput(), inputHandle, eHapticLocation, nIntensity, nGainDB, nOtherIntensity, nOtherGainDB);
}
///
/// 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 Legacy_TriggerHapticPulse(InputHandle_t inputHandle, ESteamControllerPad eTargetPad, ushort usDurationMicroSec) {
InteropHelp.TestIfAvailableClient();
NativeMethods.ISteamInput_Legacy_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 Legacy_TriggerRepeatedHapticPulse(InputHandle_t inputHandle, ESteamControllerPad eTargetPad, ushort usDurationMicroSec, ushort usOffMicroSec, ushort unRepeat, uint nFlags) {
InteropHelp.TestIfAvailableClient();
NativeMethods.ISteamInput_Legacy_TriggerRepeatedHapticPulse(CSteamAPIContext.GetSteamInput(), inputHandle, eTargetPad, usDurationMicroSec, usOffMicroSec, unRepeat, nFlags);
}
///
/// -----------------------------------------------------------------------------
/// Utility functions available 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 - unlike EInputActionOrigin which update with Steam and may return unrecognized values
/// ESteamInputType will remain static and only return valid values from your SDK version
///
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);
}
///
/// Get a bitmask of the Steam Input Configuration types opted in for the current session. Returns ESteamInputConfigurationEnableType values.
/// Note: user can override the settings from the Steamworks Partner site so the returned values may not exactly match your default configuration
///
public static ushort GetSessionInputConfigurationSettings() {
InteropHelp.TestIfAvailableClient();
return NativeMethods.ISteamInput_GetSessionInputConfigurationSettings(CSteamAPIContext.GetSteamInput());
}
///
/// Set the trigger effect for a DualSense controller
///
public static void SetDualSenseTriggerEffect(InputHandle_t inputHandle, IntPtr pParam) {
InteropHelp.TestIfAvailableClient();
NativeMethods.ISteamInput_SetDualSenseTriggerEffect(CSteamAPIContext.GetSteamInput(), inputHandle, pParam);
}
}
}
#endif // !DISABLESTEAMWORKS