steamworks-ffi-node 0.6.10 → 0.7.0

package/dist/internal/SteamInputManager.d.ts

@@ -0,0 +1,496 @@
+import { InputHandle, InputActionSetHandle, InputDigitalActionHandle, InputAnalogActionHandle, InputDigitalActionData, InputAnalogActionData, InputMotionData, SteamInputType, ControllerInfo, DeviceBindingRevision, SteamInputGlyphSize, SteamControllerPad, ControllerHapticLocation } from '../types';
+import { SteamLibraryLoader } from './SteamLibraryLoader';
+/**
+ * SteamInputManager
+ *
+ * Manages Steam Input operations for unified controller support.
+ * Supports Xbox, PlayStation, Nintendo Switch, Steam Controller, and more.
+ *
+ * Features:
+ * - Controller detection and enumeration
+ * - Action set management
+ * - Digital and analog action handling
+ * - Motion data (gyro, accelerometer)
+ * - Haptic feedback and vibration
+ * - LED control
+ * - Button glyph display
+ * - Configuration UI
+ *
+ * @example
+ * ```typescript
+ * const inputManager = new SteamInputManager(libraryLoader, apiCore);
+ *
+ * // Initialize
+ * inputManager.init();
+ *
+ * // Update every frame
+ * inputManager.runFrame();
+ *
+ * // Get connected controllers
+ * const controllers = inputManager.getConnectedControllers();
+ *
+ * // Read actions
+ * const jumpHandle = inputManager.getDigitalActionHandle('Jump');
+ * const jumpData = inputManager.getDigitalActionData(controllerHandle, jumpHandle);
+ * if (jumpData.state) {
+ *   console.log('Jump pressed!');
+ * }
+ * ```
+ */
+export declare class SteamInputManager {
+    /** Steam library loader for FFI function calls */
+    private libraryLoader;
+    /** Cached ISteamInput interface pointer */
+    private steamInputInterface;
+    /**
+     * Creates a new SteamInputManager instance
+     *
+     * @param libraryLoader - The Steam library loader for FFI calls
+     */
+    constructor(libraryLoader: SteamLibraryLoader);
+    /**
+     * Get the ISteamInput interface pointer
+     * @private
+     */
+    private getSteamInputInterface;
+    /**
+     * Initialize Steam Input
+     *
+     * Must be called before using any other Steam Input functions.
+     * Should be called after SteamAPI_Init().
+     *
+     * @param explicitlyCallRunFrame - If true, you must call runFrame() manually each frame.
+     *                                   If false, Steam will automatically update input state.
+     *                                   Default is true for explicit control.
+     * @returns True if initialization was successful
+     *
+     * @example
+     * ```typescript
+     * if (inputManager.init()) {
+     *   console.log('Steam Input initialized successfully');
+     * }
+     * ```
+     */
+    init(explicitlyCallRunFrame?: boolean): boolean;
+    /**
+     * Shutdown Steam Input
+     *
+     * Should be called before SteamAPI_Shutdown().
+     *
+     * @returns True if shutdown was successful
+     */
+    shutdown(): boolean;
+    /**
+     * Set the absolute path to the Input Action Manifest file
+     *
+     * Used for games that provide their own input_actions.vdf file.
+     * Must be called before init().
+     *
+     * @param manifestPath - Absolute path to input_actions.vdf
+     * @returns True if successful
+     */
+    setInputActionManifestFilePath(manifestPath: string): boolean;
+    /**
+     * Update input state for all controllers
+     *
+     * Must be called every frame if init() was called with explicitlyCallRunFrame=true.
+     * Synchronizes controller state and processes input data.
+     *
+     * @param reservedValue - Reserved for future use, should be false
+     *
+     * @example
+     * ```typescript
+     * // In your game loop
+     * function gameLoop() {
+     *   inputManager.runFrame();
+     *   // Read input state
+     *   // Update game logic
+     *   requestAnimationFrame(gameLoop);
+     * }
+     * ```
+     */
+    runFrame(reservedValue?: boolean): void;
+    /**
+     * Get all currently connected controller handles
+     *
+     * Controller handles persist across disconnects/reconnects.
+     *
+     * @returns Array of controller handles (max 16 controllers)
+     *
+     * @example
+     * ```typescript
+     * const controllers = inputManager.getConnectedControllers();
+     * console.log(`Found ${controllers.length} controller(s)`);
+     *
+     * controllers.forEach(handle => {
+     *   const type = inputManager.getInputTypeForHandle(handle);
+     *   console.log(`Controller: ${handle}, Type: ${type}`);
+     * });
+     * ```
+     */
+    getConnectedControllers(): InputHandle[];
+    /**
+     * Get the input type for a specific controller
+     *
+     * @param inputHandle - Controller handle
+     * @returns Controller type enum value
+     *
+     * @example
+     * ```typescript
+     * const type = inputManager.getInputTypeForHandle(handle);
+     * if (type === SteamInputType.PS5Controller) {
+     *   console.log('DualSense detected!');
+     * }
+     * ```
+     */
+    getInputTypeForHandle(inputHandle: InputHandle): SteamInputType;
+    /**
+     * Get comprehensive controller information
+     *
+     * Convenience method that combines multiple queries into one object.
+     *
+     * @param inputHandle - Controller handle
+     * @returns Controller information object
+     */
+    getControllerInfo(inputHandle: InputHandle): ControllerInfo;
+    /**
+     * Get the controller handle for a specific gamepad index
+     *
+     * Useful for mapping XInput indices to Steam Input handles.
+     *
+     * @param gamepadIndex - XInput gamepad index (0-3)
+     * @returns Controller handle, or 0n if not found
+     */
+    getControllerForGamepadIndex(gamepadIndex: number): InputHandle;
+    /**
+     * Get the gamepad index for a controller handle
+     *
+     * @param inputHandle - Controller handle
+     * @returns XInput gamepad index (0-3), or -1 if not emulating gamepad
+     */
+    getGamepadIndexForController(inputHandle: InputHandle): number;
+    /**
+     * Get the handle for an action set by name
+     *
+     * Action sets group related actions together (e.g., "MenuControls", "GameplayControls").
+     * Should be queried once at startup and cached.
+     *
+     * @param actionSetName - Name of the action set from input_actions.vdf
+     * @returns Action set handle
+     *
+     * @example
+     * ```typescript
+     * const menuSet = inputManager.getActionSetHandle('MenuControls');
+     * const gameSet = inputManager.getActionSetHandle('GameplayControls');
+     * ```
+     */
+    getActionSetHandle(actionSetName: string): InputActionSetHandle;
+    /**
+     * Activate an action set for a controller
+     *
+     * Only one action set can be active at a time (plus layers).
+     *
+     * @param inputHandle - Controller handle
+     * @param actionSetHandle - Action set handle to activate
+     *
+     * @example
+     * ```typescript
+     * const gameSet = inputManager.getActionSetHandle('GameplayControls');
+     * inputManager.activateActionSet(controllerHandle, gameSet);
+     * ```
+     */
+    activateActionSet(inputHandle: InputHandle, actionSetHandle: InputActionSetHandle): void;
+    /**
+     * Get the currently active action set for a controller
+     *
+     * @param inputHandle - Controller handle
+     * @returns Currently active action set handle
+     */
+    getCurrentActionSet(inputHandle: InputHandle): InputActionSetHandle;
+    /**
+     * Activate an action set layer
+     *
+     * Layers add additional actions on top of the base action set.
+     * Up to 16 layers can be active simultaneously.
+     *
+     * @param inputHandle - Controller handle
+     * @param actionSetLayerHandle - Action set layer handle
+     */
+    activateActionSetLayer(inputHandle: InputHandle, actionSetLayerHandle: InputActionSetHandle): void;
+    /**
+     * Deactivate an action set layer
+     *
+     * @param inputHandle - Controller handle
+     * @param actionSetLayerHandle - Action set layer handle
+     */
+    deactivateActionSetLayer(inputHandle: InputHandle, actionSetLayerHandle: InputActionSetHandle): void;
+    /**
+     * Deactivate all action set layers
+     *
+     * @param inputHandle - Controller handle
+     */
+    deactivateAllActionSetLayers(inputHandle: InputHandle): void;
+    /**
+     * Get all currently active action set layers
+     *
+     * @param inputHandle - Controller handle
+     * @returns Array of active layer handles
+     */
+    getActiveActionSetLayers(inputHandle: InputHandle): InputActionSetHandle[];
+    /**
+     * Get the handle for a digital action by name
+     *
+     * Digital actions represent button presses (on/off state).
+     * Should be queried once at startup and cached.
+     *
+     * @param actionName - Name of the digital action from input_actions.vdf
+     * @returns Digital action handle
+     *
+     * @example
+     * ```typescript
+     * const jumpHandle = inputManager.getDigitalActionHandle('Jump');
+     * const shootHandle = inputManager.getDigitalActionHandle('Shoot');
+     * ```
+     */
+    getDigitalActionHandle(actionName: string): InputDigitalActionHandle;
+    /**
+     * Get the current state of a digital action
+     *
+     * @param inputHandle - Controller handle
+     * @param digitalActionHandle - Digital action handle
+     * @returns Digital action data (state and active status)
+     *
+     * @example
+     * ```typescript
+     * const jumpData = inputManager.getDigitalActionData(controllerHandle, jumpHandle);
+     * if (jumpData.state && jumpData.active) {
+     *   player.jump();
+     * }
+     * ```
+     */
+    getDigitalActionData(inputHandle: InputHandle, digitalActionHandle: InputDigitalActionHandle): InputDigitalActionData;
+    /**
+     * Get the localized string for a digital action name
+     *
+     * @param digitalActionHandle - Digital action handle
+     * @returns Localized action name, or empty string if not found
+     */
+    getStringForDigitalActionName(digitalActionHandle: InputDigitalActionHandle): string;
+    /**
+     * Get the handle for an analog action by name
+     *
+     * Analog actions represent continuous inputs like joysticks and triggers.
+     * Should be queried once at startup and cached.
+     *
+     * @param actionName - Name of the analog action from input_actions.vdf
+     * @returns Analog action handle
+     *
+     * @example
+     * ```typescript
+     * const moveHandle = inputManager.getAnalogActionHandle('Move');
+     * const lookHandle = inputManager.getAnalogActionHandle('Look');
+     * ```
+     */
+    getAnalogActionHandle(actionName: string): InputAnalogActionHandle;
+    /**
+     * Get the current state of an analog action
+     *
+     * @param inputHandle - Controller handle
+     * @param analogActionHandle - Analog action handle
+     * @returns Analog action data (mode, x, y values, and active status)
+     *
+     * @example
+     * ```typescript
+     * const moveData = inputManager.getAnalogActionData(controllerHandle, moveHandle);
+     * if (moveData.active) {
+     *   player.move(moveData.x, moveData.y);
+     * }
+     * ```
+     */
+    getAnalogActionData(inputHandle: InputHandle, analogActionHandle: InputAnalogActionHandle): InputAnalogActionData;
+    /**
+     * Get the localized string for an analog action name
+     *
+     * @param analogActionHandle - Analog action handle
+     * @returns Localized action name, or empty string if not found
+     */
+    getStringForAnalogActionName(analogActionHandle: InputAnalogActionHandle): string;
+    /**
+     * Stop analog action momentum for trackball mode
+     *
+     * If an analog action is in trackball mode (mouse emulation),
+     * this stops the momentum/inertia.
+     *
+     * @param inputHandle - Controller handle
+     * @param analogActionHandle - Analog action handle
+     */
+    stopAnalogActionMomentum(inputHandle: InputHandle, analogActionHandle: InputAnalogActionHandle): void;
+    /**
+     * Get motion data from controller (gyroscope and accelerometer)
+     *
+     * Provides quaternion rotation, positional acceleration, and angular velocity.
+     *
+     * @param inputHandle - Controller handle
+     * @returns Motion data, or null if not supported
+     *
+     * @example
+     * ```typescript
+     * const motion = inputManager.getMotionData(controllerHandle);
+     * if (motion) {
+     *   // Use gyro for aiming
+     *   camera.rotateByGyro(motion.rotVelX, motion.rotVelY, motion.rotVelZ);
+     * }
+     * ```
+     */
+    getMotionData(inputHandle: InputHandle): InputMotionData | null;
+    /**
+     * Trigger vibration/rumble on a controller
+     *
+     * @param inputHandle - Controller handle
+     * @param leftSpeed - Left motor speed (0-65535)
+     * @param rightSpeed - Right motor speed (0-65535)
+     *
+     * @example
+     * ```typescript
+     * // Light rumble
+     * inputManager.triggerVibration(handle, 10000, 10000);
+     *
+     * // Strong rumble
+     * inputManager.triggerVibration(handle, 65535, 65535);
+     *
+     * // Stop rumble
+     * inputManager.triggerVibration(handle, 0, 0);
+     * ```
+     */
+    triggerVibration(inputHandle: InputHandle, leftSpeed: number, rightSpeed: number): void;
+    /**
+     * Trigger extended vibration with trigger motor support (Xbox controllers)
+     *
+     * @param inputHandle - Controller handle
+     * @param leftSpeed - Left motor speed (0-65535)
+     * @param rightSpeed - Right motor speed (0-65535)
+     * @param leftTriggerSpeed - Left trigger motor speed (0-65535)
+     * @param rightTriggerSpeed - Right trigger motor speed (0-65535)
+     */
+    triggerVibrationExtended(inputHandle: InputHandle, leftSpeed: number, rightSpeed: number, leftTriggerSpeed: number, rightTriggerSpeed: number): void;
+    /**
+     * Trigger a simple haptic event (Steam Controller, Steam Deck)
+     *
+     * @param inputHandle - Controller handle
+     * @param hapticLocation - Left, right, or both
+     * @param intensity - Intensity (0-255)
+     * @param gainDB - Gain in decibels
+     * @param otherIntensity - Intensity for the other pad
+     * @param otherGainDB - Gain for the other pad
+     */
+    triggerSimpleHapticEvent(inputHandle: InputHandle, hapticLocation: ControllerHapticLocation, intensity: number, gainDB: number, otherIntensity: number, otherGainDB: number): void;
+    /**
+     * Set controller LED color (supported controllers only)
+     *
+     * @param inputHandle - Controller handle
+     * @param colorR - Red (0-255)
+     * @param colorG - Green (0-255)
+     * @param colorB - Blue (0-255)
+     * @param flags - LED flags (0 = set color, 1 = restore default)
+     *
+     * @example
+     * ```typescript
+     * // Set LED to red
+     * inputManager.setLEDColor(handle, 255, 0, 0, 0);
+     *
+     * // Set LED to blue
+     * inputManager.setLEDColor(handle, 0, 0, 255, 0);
+     *
+     * // Restore default LED color
+     * inputManager.setLEDColor(handle, 0, 0, 0, 1);
+     * ```
+     */
+    setLEDColor(inputHandle: InputHandle, colorR: number, colorG: number, colorB: number, flags?: number): void;
+    /**
+     * Trigger a legacy haptic pulse (Steam Controller)
+     *
+     * @param inputHandle - Controller handle
+     * @param targetPad - Left or right pad
+     * @param durationMicroSec - Duration in microseconds
+     */
+    legacyTriggerHapticPulse(inputHandle: InputHandle, targetPad: SteamControllerPad, durationMicroSec: number): void;
+    /**
+     * Get the path to a PNG glyph for an action origin
+     *
+     * Useful for showing button prompts in your UI.
+     *
+     * @param origin - Action origin (button)
+     * @param size - Glyph size (small, medium, large)
+     * @param flags - Glyph style flags
+     * @returns Path to PNG file, or empty string if not available
+     *
+     * @example
+     * ```typescript
+     * const origins = inputManager.getDigitalActionOrigins(handle, actionSet, jumpHandle);
+     * if (origins.length > 0) {
+     *   const glyphPath = inputManager.getGlyphPNGForActionOrigin(
+     *     origins[0],
+     *     SteamInputGlyphSize.Medium,
+     *     SteamInputGlyphStyle.Dark
+     *   );
+     *   // Display glyph image in UI
+     * }
+     * ```
+     */
+    getGlyphPNGForActionOrigin(origin: number, size: SteamInputGlyphSize, flags: number): string;
+    /**
+     * Get the path to an SVG glyph for an action origin
+     *
+     * @param origin - Action origin (button)
+     * @param flags - Glyph style flags
+     * @returns Path to SVG file, or empty string if not available
+     */
+    getGlyphSVGForActionOrigin(origin: number, flags: number): string;
+    /**
+     * Get localized string for an action origin
+     *
+     * @param origin - Action origin (button)
+     * @returns Localized button name (e.g., "A Button", "Cross")
+     */
+    getStringForActionOrigin(origin: number): string;
+    /**
+     * Open the Steam Input configuration UI
+     *
+     * Shows the binding panel where users can customize their controller configuration.
+     *
+     * @param inputHandle - Controller handle
+     * @returns True if successful
+     *
+     * @example
+     * ```typescript
+     * // In your settings menu
+     * if (userClicksConfigureController) {
+     *   inputManager.showBindingPanel(controllerHandle);
+     * }
+     * ```
+     */
+    showBindingPanel(inputHandle: InputHandle): boolean;
+    /**
+     * Get the binding revision for a device
+     *
+     * @param inputHandle - Controller handle
+     * @returns Device binding revision, or null if not available
+     */
+    getDeviceBindingRevision(inputHandle: InputHandle): DeviceBindingRevision | null;
+    /**
+     * Get the Remote Play session ID for a controller
+     *
+     * @param inputHandle - Controller handle
+     * @returns Session ID, or 0 if not in a Remote Play session
+     */
+    getRemotePlaySessionID(inputHandle: InputHandle): number;
+    /**
+     * Get the current session input configuration settings
+     *
+     * Returns a bitmask of ESteamInputConfigurationEnableType values.
+     *
+     * @returns Configuration settings bitmask
+     */
+    getSessionInputConfigurationSettings(): number;
+}
+//# sourceMappingURL=SteamInputManager.d.ts.map

package/dist/internal/SteamInputManager.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SteamInputManager.d.ts","sourceRoot":"","sources":["../../src/internal/SteamInputManager.ts"],"names":[],"mappings":"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"}