MUA HỘ & SHIP TỪ MỸ VỀ VIỆT NAM

Interfacing with external devices designed to control games has the potential to become large and intractable if approached in full generality. In this specification we explicitly choose to narrow scope to provide a useful subset of functionality that can be widely implemented and broadly useful.

Specifically, we choose to only support the functionality required to support gamepads. Support for gamepads requires two input types: buttons and axes. Both buttons and axes are reported as analog values, buttons ranging from [0..1], and axes ranging from [-1..1].

While the primary goal is support for gamepad devices, supporting these two types of analog inputs allows support for other similar devices common to current gaming systems including joysticks, driving wheels, pedals, and accelerometers. As such, the name "gamepad" is exemplary rather than trying to be a generic name for the entire set of devices addressed by this specification.

We specifically exclude support for more complex devices that may also be used in some gaming contexts, including those that that do motion sensing, depth sensing, video analysis, gesture recognition, and so on.

This interface defines an individual gamepad device.

WebIDL[Exposed=Window] interface Gamepad {   readonly attribute DOMString id;   readonly attribute long index;   readonly attribute boolean connected;   readonly attribute DOMHighResTimeStamp timestamp;   readonly attribute GamepadMappingType mapping;   readonly attribute FrozenArray<double> axes;   readonly attribute FrozenArray<GamepadButton> buttons;   readonly attribute FrozenArray<GamepadTouch> touches;   [SameObject] readonly attribute GamepadHapticActuator vibrationActuator; };

The algorithms used to communicate with the system typically complete asynchronously, queuing work on the gamepad task source.

Instances of Gamepad are created with the internal slots described in the following table:

Internal slot	Initial value	Description (non-normative)
[[connected]]	`false`	A flag indicating that the device is connected to the system
[[timestamp]]	undefined	The last time data for this `Gamepad` was updated
[[axes]]	An empty sequence	A sequence of `double` values representing the current state of axes exposed by this device
[[buttons]]	An empty sequence	A sequence of `GamepadButton` objects representing the current state of buttons exposed by this device
[[exposed]]	`false`	A flag indicating that the `Gamepad` object has been exposed to script
[[axisMapping]]	An empty ordered map	Mapping from unmapped axis index to an index in the `axes` array
[[axisMinimums]]	An empty list	A list containing the minimum logical value for each axis
[[axisMaximums]]	An empty list	A list containing the maximum logical value for each axis
[[buttonMapping]]	An empty ordered map	Mapping from unmapped button index to an index in the `buttons` array
[[buttonMinimums]]	An empty list	A list containing the minimum logical value for each button.
[[buttonMaximums]]	An empty list	A list containing the maximum logical value for each button
[[touches]]	Initialize to an is empty list	Holds the list of user-generated touches, if any. If the gamepad does not support touch surfaces, then the list will remain empty.
[[nextTouchId]]	Initialize to 0	Touch id to use for the next incoming touch.
[[vibrationActuator]]	undefined	A `GamepadHapticActuator` object capable of generating a haptic effect that vibrates the entire gamepad

id attribute

An identification string for the gamepad. This string identifies the brand or style of connected gamepad device.

The exact format of the id string is left unspecified. It is RECOMMENDED that the user agent select a string that identifies the product without uniquely identifying the device. For example, a USB gamepad may be identified by its idVendor and idProduct values. Unique identifiers like serial numbers or Bluetooth device addresses MUST NOT be included in the id string.

index attribute

The index of the gamepad in the Navigator. When multiple gamepads are connected to a user agent, indices MUST be assigned on a first-come, first-serve basis, starting at zero. If a gamepad is disconnected, previously assigned indices MUST NOT be reassigned to gamepads that continue to be connected. However, if a gamepad is disconnected, and subsequently the same or a different gamepad is then connected, the lowest previously used index MUST be reused.

connected attribute

Indicates whether the physical device represented by this object is still connected to the system. When a gamepad becomes unavailable, whether by being physically disconnected, powered off or otherwise unusable, the connected attribute MUST be set to false.

The connected getter steps are:

Return this.[[connected]].

timestamp attribute

The timestamp allows the author to determine the last time the axes or buttons attribute for this gamepad was updated. The value MUST be set to the current high resolution time each time the system receives new button or axis input values from the device. If no data has been received from the hardware, timestamp MUST be the current high resolution time at the time when the Gamepad was first made available to script.

Warning

User agents SHOULD set a minimum resolution of gamepad's timestamp attribute to 5 microseconds, following [HR-TIME]'s clock resolution recommendation.

The timestamp getter steps are:

Return this.[[timestamp]].

mapping attribute

The mapping in use for this device. If the user agent has knowledge of the layout of the device, then it SHOULD indicate that a mapping is in use by setting mapping to the corresponding GamepadMappingType value.

To select a mapping for a gamepad device, run the following steps:

If the button and axis layout of the gamepad device corresponds with the Standard Gamepad layout, then return "standard".
Return "".

axes attribute

Array of values for all axes of the gamepad. All axis values MUST be linearly normalized to the range [-1.0 .. 1.0]. If the controller is perpendicular to the ground with the directional stick pointing up, -1.0 SHOULD correspond to "forward" or "left", and 1.0 SHOULD correspond to "backward" or "right". Axes that are drawn from a 2D input device SHOULD appear next to each other in the axes array, X then Y. It is RECOMMENDED that axes appear in decreasing order of importance, such that element 0 and 1 typically represent the X and Y axis of a directional stick. The same object MUST be returned until the user agent needs to return different values (or values in a different order).

The axes getter steps are:

Return this.[[axes]].

buttons attribute

Array of button states for all buttons of the gamepad. It is RECOMMENDED that buttons appear in decreasing importance such that the primary button, secondary button, tertiary button, and so on appear as elements 0, 1, 2, ... in the buttons array. The same object MUST be returned until the user agent needs to return different values (or values in a different order).

The buttons getter steps are:

Return this.[[buttons]].

touches attribute

A list of GamepadTouch objects generated from all touch surfaces.

The touches getter steps are:

Return this.[[touches]].

vibrationActuator attribute

A GamepadHapticActuator object that represents the device's primary vibration actuator.

The vibrationActuator getter steps are:

Return this.[[vibrationActuator]].

When the system receives new button or axis input values, run the following steps:

Let gamepad be the Gamepad object representing the device that received new button or axis input values.
Queue a task on the gamepad task source to update gamepad state for gamepad.

To update gamepad state for gamepad, run the following steps:

Let now be the current high resolution time.
Set gamepad.[[timestamp]] to now.
Run the steps to map and normalize axes for gamepad.
Run the steps to map and normalize buttons for gamepad.
Run the steps to record touches for gamepad.
Let navigator be gamepad's relevant global object's Navigator object.
If navigator.[[hasGamepadGesture]] is false and gamepad contains a gamepad user gesture:
1. Set navigator.[[hasGamepadGesture]] to true.
2. For each connectedGamepad of navigator.[[gamepads]]:
  1. If connectedGamepad is not equal to null:
    1. Set connectedGamepad.[[exposed]] to true.
    2. Set connectedGamepad.[[timestamp]] to now.
    3. Let document be gamepad's relevant global object's associated Document; otherwise null.
    4. If document is not null and is fully active, then queue a task on the gamepad task source to fire an event named gamepadconnected at gamepad's relevant global object using GamepadEvent with its gamepad attribute initialized to connectedGamepad.

To map and normalize axes for gamepad, run the following steps:

Let axisValues be a list of unsigned long values representing the most recent logical axis input values for each axis input of the device represented by gamepad.
Let maxRawAxisIndex be the size of axisValues − 1.
For each rawAxisIndex of the range from 0 to maxRawAxisIndex:
1. Let mappedIndex be gamepad.[[axisMapping]][rawAxisIndex].
2. Let logicalValue be axisValues[rawAxisIndex].
3. Let logicalMinimum be gamepad.[[axisMinimums]][rawAxisIndex].
4. Let logicalMaximum be gamepad.[[axisMaximums]][rawAxisIndex].
5. Let normalizedValue be 2 (logicalValue − logicalMinimum) / (logicalMaximum − logicalMinimum) − 1.
6. Set gamepad.[[axes]][axisIndex] to be normalizedValue.

To map and normalize buttons for gamepad, run the following steps:

Let buttonValues be a list of unsigned long values representing the most recent logical button input values for each button input of the device represented by gamepad.
Let maxRawButtonIndex be the size of buttonValues − 1.
For each rawButtonIndex of the range from 0 to maxRawButtonIndex:
1. Let mappedIndex be gamepad.[[buttonMapping]][rawButtonIndex].
2. Let logicalValue be buttonValues[rawButtonIndex].
3. Let logicalMinimum be gamepad.[[buttonMinimums]][rawButtonIndex].
4. Let logicalMaximum be gamepad.[[buttonMaximums]][rawButtonIndex].
5. Let normalizedValue be (logicalValue − logicalMinimum) / (logicalMaximum − logicalMinimum).
6. Let button be gamepad.[[buttons]][mappedIndex].
7. Set button.[[value]] to normalizedValue.
8. If the button has a digital switch to indicate a pure pressed or released state, set button.[[pressed]] to true if the button is pressed or false if it is not pressed.
  
  Otherwise, set button.[[pressed]] to true if the value is above the button press threshold or false if it is not above the threshold.
9. If the button is capable of detecting touch, set button.[[touched]] to true if the button is currently being touched.
  
  Otherwise, set button.[[touched]] to button.[[pressed]].

To record touches for gamepad, run the following steps:

Assert: Gamepad.[[touches]] is empty.
Repeat the following steps for each touch surface on gamepad in touch surface enumeration order:
1. Let surfaceId be the current surface enumeration index.
2. If the touch surface exposes maximum surface dimensions in device units, then set touch.surfaceDimensions to a DOMRectReadOnly with width and height initialized to the maximum X and Y dimensions on the touch surface in device units.
3. Repeat the following steps for each active touch point reported by the gamepad for the current touch surface.
  1. Let touch be a newly created GamepadTouch object.
  2. Set touch.surfaceId to be surfaceId.
  3. If the touch data is part of an existing active touch point tracked by the user agent:
    1. Set touch.touchId to the touchId of the active touch point.
    2. Otherwise, set touchId to nextTouchId and increment nextTouchId.
      Note: Touch ids are relative to the Gamepad
      If the Gamepad has multiple touch surfaces the touch id will be unique across surfaces.
  4. Set touch.position to a new DOMPointReadOnly with x initialized to device X coordinate relative to the device touch surface and normalized to [-1.0,1.0] where -1.0 is the leftmost coordinate and 1.0 is the rightmost coordinate and y initialized to the device touch surface and normalized to [-1.0,1.0] where -1.0 is the leftmost coordinate and 1.0 is the rightmost coordinate.
    Note: Possible implementation (if surfaceDimensions are available)
    x = (2.0 * touchData.x / surfaceDimensions.width) - 1
    
    Note: Possible implementation (if surfaceDimensions are available)
    y = (2.0 * touchData.y / surfaceDimensions.height) - 1
  5. Add touch to Gamepad.[[touches]].

A new Gamepad representing a connected gamepad device is constructed by performing the following steps:

Let gamepad be a newly created Gamepad instance:
1. Initialize gamepad's id attribute to an identification string for the gamepad.
2. Initialize gamepad's index attribute to the result of selecting an unused gamepad index for gamepad.
3. Initialize gamepad's mapping attribute to the result of selecting a mapping for the gamepad device.
4. Initialize gamepad.[[connected]] to true.
5. Initialize gamepad.[[timestamp]] to the current high resolution time.
6. Initialize gamepad.[[axes]] to the result of initializing axes for gamepad.
7. Initialize gamepad.[[buttons]] to the result of initializing buttons for gamepad.
8. Initialize gamepad.[[vibrationActuator]] following the steps of constructing a GamepadHapticActuator for gamepad.
Return gamepad.

To select an unused gamepad index for gamepad, run the following steps:

Let navigator be gamepad's relevant global object's Navigator object.
Let maxGamepadIndex be the size of navigator.[[gamepads]] − 1.
For each gamepadIndex of the range from 0 to maxGamepadIndex:
1. If navigator.[[gamepads]][gamepadIndex] is null, then return gamepadIndex.
Append null to navigator.[[gamepads]].
Return the size of navigator.[[gamepads]] − 1.

To initialize axes for gamepad, run the following steps:

Let inputCount be the number of axis inputs exposed by the device represented by gamepad.
Set gamepad.[[axisMinimums]] to a list of unsigned long values with size equal to inputCount containing minimum logical values for each of the axis inputs.
Set gamepad.[[axisMaximums]] to a list of unsigned long values with size equal to inputCount containing maximum logical values for each of the axis inputs.
Initialize unmappedInputList to be an empty list.
Initialize mappedIndexList to be an empty list.
Initialize axesSize to be 0.
For each rawInputIndex of the range from 0 to inputCount − 1:
1. If the the gamepad axis at index rawInputIndex represents a Standard Gamepad axis:
  1. Let canonicalIndex be the canonical index for the axis.
  2. If mappedIndexList contains canonicalIndex, then append rawInputIndex to unmappedInputList.
    Otherwise:
    1. Set gamepad.[[axisMapping]][rawInputIndex] to canonicalIndex.
    2. Append canonicalIndex to mappedIndexList.
    3. If canonicalIndex + 1 is greater than axesSize, then set axesSize to canonicalIndex + 1.
  Otherwise, append rawInputIndex to unmappedInputList.
Initialize axisIndex to be 0.
For each rawInputIndex of unmappedInputList:
1. While mappedIndexList contains axisIndex:
  1. Increment axisIndex.
2. Set gamepad.[[axisMapping]][rawInputIndex] to axisIndex.
3. Append axisIndex to mappedIndexList.
4. If axisIndex + 1 is greater than axesSize, then set axesSize to axisIndex + 1.
Initialize axes to be an empty list.
For each axisIndex of the range from 0 to axesSize − 1, append 0 to axes.
Return axes.

To initialize buttons for a gamepad, run the following steps:

Let inputCount be the number of button inputs exposed by the device represented by gamepad.
Set gamepad.[[buttonMinimums]] to be a list of unsigned long values with size equal to inputCount containing minimum logical values for each of the button inputs.
Set gamepad.[[buttonMaximums]] to be a list of unsigned long values with size equal to inputCount containing maximum logical values for each of the button inputs.
Initialize unmappedInputList to be an empty list.
Initialize mappedIndexList to be an empty list.
Initialize buttonsSize to be 0.
For each rawInputIndex of the range from 0 to inputCount − 1:
1. If the the gamepad button at index rawInputIndex represents a Standard Gamepad button:
  1. Let canonicalIndex be the canonical index for the button.
  2. If mappedIndexList contains canonicalIndex, then append rawInputIndex to unmappedInputList.
    Otherwise:
    1. Set gamepad.[[buttonMapping]][rawInputIndex] to canonicalIndex.
    2. Append canonicalIndex to mappedIndexList.
    3. If canonicalIndex + 1 is greater than buttonsSize, then set buttonsSize to canonicalIndex + 1.
  Otherwise, append rawInputIndex to unmappedInputList.
2. Increment rawInputIndex.
Initialize buttonIndex to be 0.
For each rawInputIndex of unmappedInputList:
1. While mappedIndexList contains buttonIndex:
  1. Increment buttonIndex.
2. Set gamepad.[[buttonMapping]][rawInputIndex] to buttonIndex.
3. Append buttonIndex to mappedIndexList.
4. If buttonIndex + 1 is greater than buttonsSize, then set buttonsSize to buttonIndex + 1.
Initialize buttons to be an empty list.
For each buttonIndex of the range from 0 to buttonsSize − 1, append a new GamepadButton to buttons.
Return buttons.

This interface defines the state of an individual button on a gamepad device.

WebIDL[Exposed=Window] interface GamepadButton {   readonly attribute boolean pressed;   readonly attribute boolean touched;   readonly attribute double value; };

Instances of GamepadButton are created with the internal slots described in the following table:

Internal slot	Initial value	Description (non-normative)
[[pressed]]	`false`	A flag indicating that the button is pressed
[[touched]]	`false`	A flag indicating that the button is touched
[[value]]	0.0	A `double` representing the button value scaled to the range [0.0 .. 1.0]

pressed attribute

The pressed state of the button. This property MUST be true if the button is currently pressed, and false if it is not pressed. For buttons which do not have a digital switch to indicate a pure pressed or released state, the user agent MUST choose a button press threshold to indicate the button as pressed when its value is above a certain amount. If the platform API gives a recommended value, the user agent SHOULD use that. In other cases, the user agent SHOULD choose some other reasonable value.

The pressed getter steps are:

Return this.[[pressed]].

touched attribute

The touched state of the button. If the button is capable of detecting touch, this property MUST be true if the button is currently being touched, and false otherwise. If the button is not capable of detecting touch and is capable of reporting an analog value, this property MUST be true if the value property is greater than 0, and false if the value is 0. If the button is not capable of detecting touch and can only report a digital value, this property MUST mirror the pressed attribute.

The touched getter steps are:

Return this.[[touched]].

value attribute

For buttons that have an analog sensor, this property MUST represent the amount which the button has been pressed. All button values MUST be linearly normalized to the range [0.0 .. 1.0]. 0.0 MUST mean fully unpressed, and 1.0 MUST mean fully pressed. For buttons without an analog sensor, only the values 0.0 and 1.0 for fully unpressed and fully pressed respectively, MUST be provided.

The value getter steps are:

Return this.[[value]].

This interface defines a touch on a gamepad's touch surface that supports such input. The object consists of a touch touchId that uniquely identifies the touch point from the time the input medium (e.g. finger, stylus, etc) makes contact with the touch device, up to the time the input medium is no longer making contact with the touch device.

WebIDLdictionary GamepadTouch {   unsigned long touchId;   octet surfaceId;   DOMPointReadOnly position;   DOMRectReadOnly? surfaceDimensions; };

touchId attribute: Unique id of the touch. Range is [0, 4294967295].
surfaceId: Unique id of the surface that generated the touch.
position: A DOMPointReadOnly which holds the x, y coordinates of the touch. The z and w value are currently unused. The range of each coordinate is normalized to [-1.0, 1.0]. Along the x-axis, -1.0 references the leftmost coordinate and 1.0 references the rightmost coordinate. Along the y-axis, -1.0 references the topmost coordinate and 1.0 references the bottommost coordinate.
surfaceDimensions: A DOMRectReadOnly initialized with the width and height of the touch surface in integer units. If not available then null.

This enum defines the set of known mappings for a Gamepad.

WebIDLenum GamepadMappingType {   "",   "standard",   "xr-standard", };

"": The empty string indicates that no mapping is in use for this gamepad.
"standard": The Gamepad's controls have been mapped to the Standard Gamepad layout.
"xr-standard": The Gamepad's controls have been mapped to the "xr-standard" gamepad mapping. This mapping is reserved for use by the WebXR Gamepads Module - Level 1. Gamepads returned by getGamepads() MUST NOT report a mapping of "xr-standard".

A GamepadHapticActuator corresponds to a configuration of motors or other actuators that can apply a force for the purposes of haptic feedback.

WebIDL[Exposed=Window] interface GamepadHapticActuator {   [SameObject] readonly attribute FrozenArray<GamepadHapticEffectType> effects;   Promise<GamepadHapticsResult> playEffect(       GamepadHapticEffectType type,       optional GamepadEffectParameters params = {}   );   Promise<GamepadHapticsResult> reset(); };

Instances of GamepadHapticActuator are created with the internal slots described in the following table:

Internal slot	Initial value	Description
[[effects]]	An empty list of `GamepadHapticEffectType`.	Represents the effects supported by the actuator.
[[playingEffectPromise]]	`null`	The `Promise` to play some effect, or `null` if no effect is playing.

effects attribute

Array of GamepadHapticEffectType values representing all the types of haptic effects that the actuator supports. This property lists the GamepadHapticEffectType values that the actuator supports, unless the user agent does not support playing effects of that type.

The effects getter steps are:

Return this.[[effects]].

playEffect() method

The playEffect() method steps, called with GamepadHapticEffectType type and GamepadEffectParameters params, are:

If params does not describe a valid effect of type type, return a promise rejected with a TypeError.
Let document be the current settings object's relevant global object's associated Document.
If document is null or document is not fully active or document's visibility state is "hidden", return a promise rejected with an "InvalidStateError" DOMException.
If this.[[playingEffectPromise]] is not null:
1. Let effectPromise be this.[[playingEffectPromise]].
2. Set this.[[playingEffectPromise]] to null.
3. Queue a global task on the relevant global object of this using the gamepad task source to resolve effectPromise with "preempted".
If this's gamepad's actuator cannot play effects with type type, return a promise rejected with reason NotSupportedError.
Let [[playingEffectPromise]] be a new promise.
Let playEffectTimestamp be the current high resolution time given the document's relevant global object.
Do the following steps in parallel:
1. Issue a haptic effect to the actuator with type, params, and the playEffectTimestamp.
2. When the effect completes, if this.[[playingEffectPromise]] is not null, queue a global task on the relevant global object of this using the gamepad task source to run the following steps:
  1. If this.[[playingEffectPromise]] is null, abort these steps.
  2. Resolve this.[[playingEffectPromise]] with "complete".
  3. Set this.[[playingEffectPromise]] to null.
Return [[playingEffectPromise]].

reset() method

The reset() method steps are:

Let document be the current settings object's relevant global object's associated Document.
If document is null or document is not fully active or document's visibility state is "hidden", return a promise rejected with an "InvalidStateError" DOMException.
Let resetResultPromise be a new promise.
If this.[[playingEffectPromise]] is not null, do the following steps in parallel:
1. Let effectPromise be this.[[playingEffectPromise]].
2. Stop haptic effects on this's gamepad's actuator.
3. If the effect has been successfully stopped, do:
  1. If effectPromise and this.[[playingEffectPromise]] are still the same, set this.[[playingEffectPromise]] to null.
  2. Queue a global task on the relevant global object of this using the gamepad task source to resolve effectPromise with "preempted".
4. Resolve resetResultPromise with "complete"
Return resetResultPromise.

A GamepadHapticActuator can play effects with type type if type can be found in the [[effects]] list.

To check if an effect with GamepadHapticEffectType type and GamepadEffectParameters params describes a valid effect, run the following steps:

Given the value of GamepadHapticEffectType type, switch on:

"dual-rumble"

If params does not describe a valid dual-rumble effect, return false.

"trigger-rumble"

If params does not describe a valid trigger-rumble effect, return false.
Return true

To issue a haptic effect on an actuator, the user agent MUST send a command to the device to render an effect of type and try to make it use the provided params. The user agent SHOULD use the provided playEffectTimestamp for more precise playback timing when params.startDelay is not 0.0. The user agent MAY modify the effect to increase compatibility. For example, an effect intended for a rumble motor may be transformed into a waveform-based effect for a device that supports waveform haptics but lacks rumble motors.

To stop haptic effects on an actuator, the user agent MUST send a command to the device to abort any effects currently being played. If a haptic effect was interrupted, the actuator SHOULD return to a motionless state as quickly as possible.

When the document's visibility state becomes "hidden", run these steps for each GamepadHapticActuator actuator:

If actuator.[[playingEffectPromise]] is null, abort these steps.
Queue a global task on the relevant global object of actuator using the gamepad task source to run the following steps:
1. If actuator.[[playingEffectPromise]] is null, abort these steps.
2. Resolve actuator.[[playingEffectPromise]] with "preempted".
3. Set actuator.[[playingEffectPromise]] to null.
Stop haptic effects on actuator.

A new gamepadHapticActuator representing a Gamepad's primary vibration actuator is constructed by performing the following steps:

Let gamepadHapticActuator be a newly created GamepadHapticActuator instance.
Let supportedEffectsList be an empty list.
For each enum value type of GamepadHapticEffectType, if the user agent can send a command to initiate effects of that type on that actuator, append type to supportedEffectsList.
Set gamepadHapticActuator.[[effects]] to supportedEffectsList.

WebIDLenum GamepadHapticsResult {   "complete",   "preempted" };

complete: The haptic effected completed playing.
preempted: The current effect was stopped or replaced (i.e., "preempted") by another effect.

The effect type defines how the effect parameters are interpreted by the actuator.

WebIDLenum GamepadHapticEffectType {   "dual-rumble",   "trigger-rumble" };

"dual-rumble" effect type

"dual-rumble" describes a haptic configuration with an eccentric rotating mass (ERM) vibration motor in each handle of a standard gamepad. In this configuration, either motor is capable of vibrating the whole gamepad. The vibration effects created by each motor are unequal so that the effects of each can be combined to create more complex haptic effects.

A "dual-rumble" effect is a fixed-duration, constant-intensity vibration effect intended for an actuator of this type. "dual-rumble" effects are defined by startDelay, duration, strongMagnitude, and weakMagnitude, none of which are required because they default to 0.

strongMagnitude and weakMagnitude set the intensity levels for the low-frequency and high-frequency vibrations, normalized to the range [0,1], defaulting to 0.

Given GamepadEffectParameters params, a valid dual-rumble effect must have a valid duration, a valid startDelay, and both the strongMagnitude and the weakMagnitude must be in the range [0,1].

"trigger-rumble" effect type

"trigger-rumble" describes a haptics configuration with a vibration motor in each of the bottom front buttons of a Standard Gamepad (buttons with canonical indices 6 and 7) in addition to the two handle motors used for "dual-rumble". These buttons most commonly take the form of spring-loaded triggers. In this configuration, either motor is capable of providing localized haptic feedback on the button's surface.

A "trigger-rumble" effect is a fixed-duration, constant-intensity vibration effect intended for an actuator of this type. "trigger-rumble" effects are defined by startDelay, duration, strongMagnitude, weakMagnitude, leftTrigger, and rightTrigger, none of which are required because they default to 0.

startDelay, duration, strongMagnitude, weakMagnitude share the same definition with "dual-rumble". leftTrigger and rightTrigger, respectively, set the intensity levels for the left and right bottom front buttons vibrations, normalized to the range [0,1], defaulting to 0.

Given GamepadEffectParameters params, a valid trigger-rumble effect must have a valid duration, a valid startDelay, and the strongMagnitude, weakMagnitude, leftTrigger, and rightTrigger must be in the range [0,1].

A GamepadEffectParameters dictionary contains keys for parameters used by haptic effects. The meaning of each key is defined by the haptic effect, and some keys may be unused.

To mitigate unwanted long-running effects, the user agent MAY limit the total effect duration for a valid effect to some maximum duration. It is RECOMMENDED that the user agent use a maximum of 5 seconds.

WebIDLdictionary GamepadEffectParameters {     unsigned long long duration = 0;     unsigned long long startDelay = 0;     double strongMagnitude = 0.0;     double weakMagnitude = 0.0;     double leftTrigger = 0.0;     double rightTrigger = 0.0; };

duration member: duration sets the duration of the vibration effect in milliseconds.
startDelay member: startDelay sets the duration of the delay after playEffect() is called until vibration is started, in milliseconds. During the delay interval, the actuator SHOULD NOT vibrate.
strongMagnitude member: The vibration magnitude for the low frequency rumble in a "dual-rumble" or "trigger-rumble" effect.
weakMagnitude member: The vibration magnitude for the high frequency rumble in a "dual-rumble" or "trigger-rumble" effect.
leftTrigger member: The vibration magnitude for the bottom left front button (canonical index 6) rumble in a "trigger-rumble" effect.
rightTrigger member: The vibration magnitude for the bottom right front button (canonical index 7) rumble in a "trigger-rumble" effect.

WebIDL[Exposed=Window] partial interface Navigator {   sequence<Gamepad?> getGamepads(); };

Instances of Navigator are created with the internal slots described in the following table:

Internal slot	Initial value	Description (non-normative)
[[hasGamepadGesture]]	`false`	A flag indicating that a gamepad user gesture has been observed
[[gamepads]]	A empty sequence of `Gamepad?` objects	Each `Gamepad` present at the index specified by its `index` attribute, or `null` for unassigned indices.

Note

The gamepad state returned from getGamepads() does not reflect disconnection or connection until after the gamepaddisconnected or gamepadconnected events have fired.

Note

To mitigate fingerprinting, getGamepads() returns an empty list before a gamepad user gesture has been seen. [FINGERPRINTING-GUIDANCE]

Example 1

getGamepads() returns a snapshot of the data for the currently connected and interacted-with gamepads. When a gamepad is no longer connected, its index in the array should return null. If there is one connected gamepad with an index of 1, then the following code snippet describes the expected behavior:

// gamepads should look like [null, [object Gamepad]] var gamepads = navigator.getGamepads(); // The following statements should all evaluate to true. gamepads[0] == null; gamepads[1].index == 1; gamepads.length == 2;

The getGamepads() method steps are:

Let doc be the current global object's associated Document.
If doc is null or doc is not fully active, then return an empty list.
If doc is not allowed to use the "gamepad" permission, then throw a "SecurityError" DOMException and abort these steps.
If this.[[hasGamepadGesture]] is false, then return an empty list.
Let now be the current high resolution time.
Let gamepads be an empty list.
For each gamepad of this.[[gamepads]]:
1. If gamepad is not null and gamepad.[[exposed]] is false:
  1. Set gamepad.[[exposed]] to true.
  2. Set gamepad.[[timestamp]] to now.
2. Append gamepad to gamepads.
Return gamepads.

A gamepad contains a gamepad user gesture if the current input state indicates that the user is currently interacting with the gamepad. The user agent MUST provide an algorithm to check if the input state contains a gamepad user gesture. For buttons that support a neutral default value and have reported a pressed value of false at least once, a pressed value of true SHOULD be considered interaction. If a button does not support a neutral default value (for example, a toggle switch), then a pressed value of true SHOULD NOT be considered interaction. If a button has never reported a pressed value of false then it SHOULD NOT be considered interaction. Axis movements SHOULD be considered interaction if the axis supports a neutral default value, the current displacement from neutral is greater than a threshold chosen by the user agent, and the axis has reported a value below the threshold at least once. If an axis does not support a neutral default value (for example, an axis for a joystick that does not self-center), or an axis has never reported a value below the axis gesture threshold, then the axis SHOULD NOT be considered when checking for interaction. The axis gesture threshold SHOULD be large enough that random jitter is not considered interaction.

WebIDL[Exposed=Window]  interface GamepadEvent: Event {   constructor(DOMString type, GamepadEventInit eventInitDict);   [SameObject] readonly attribute Gamepad gamepad; };

gamepad: The gamepad attribute provides access to the associated gamepad data for this event.

WebIDLdictionary GamepadEventInit : EventInit {   required Gamepad gamepad; };

gamepad member: The Gamepad associated with this event.

Each device manufacturer creates many different products and each has unique styles and layouts of buttons and axes. It is intended that the user agent support as many of these as possible.

Additionally there are de facto standard layouts that have been made popular by game consoles. When the user agent recognizes the attached device, it is RECOMMENDED that it be remapped to a canonical ordering when possible. Devices that are not recognized should still be exposed in their raw form.

There is currently one canonical layout, the Standard Gamepad. When remapping, the indices in axes and buttons should correspond as closely as possible to the physical locations in the diagram below. Additionally, mapping SHOULD be set to "standard".

The Standard Gamepad buttons are laid out in a left cluster of four buttons, a right cluster of four buttons, a center cluster of three buttons, and a pair of front facing buttons on the left and right side of the gamepad. The four axes of the "Standard Gamepad" are associated with a pair of analog sticks, one on the left and one on the right. The following table describes the buttons/axes and their physical locations.

An axis input represents a Standard Gamepad axis if it reports the input value for a thumbstick axis, the thumbstick is located in approximately the same location as the corresponding Standard Gamepad thumbstick, and the orientation of the axis (up-down or left-right) matches the orientation of the Standard Gamepad axis. If there are multiple axes that represent the same Standard Gamepad axis, then the user agent SHOULD select one to be the Standard Gamepad axis and assign a different index to the other axis.

A button input represents a Standard Gamepad button if it reports the input value for a button or trigger, and the button or trigger is located in approximately the same location as the corresponding Standard Gamepad button.

If an axis or button input represents a Standard Gamepad axis or button, then its canonical index is the index of the corresponding Standard Gamepad axis or button.

Type	Index	Location
Button	0	Bottom button in right cluster
	1	Right button in right cluster
	2	Left button in right cluster
	3	Top button in right cluster
	4	Top left front button
	5	Top right front button
	6	Bottom left front button
	7	Bottom right front button
	8	Left button in center cluster
	9	Right button in center cluster
	10	Left stick pressed button
	11	Right stick pressed button
	12	Top button in left cluster
	13	Bottom button in left cluster
	14	Left button in left cluster
	15	Right button in left cluster
	16	Center button in center cluster
axes	0	Horizontal axis for left stick (negative left/positive right)
	1	Vertical axis for left stick (negative up/positive down)
	2	Horizontal axis for right stick (negative left/positive right)
	3	Vertical axis for right stick (negative up/positive down)

Figure 1 Visual representation of a Standard Gamepad layout.

Inspecting the capabilities of Gamepad objects can be used as a means of active fingerprinting. The user agent MAY alter the device information exposed through the API to reduce the fingerprinting surface. As an example, an implementation can require that a Gamepad object have exactly the number of buttons and axes defined in the Standard Gamepad layout even if more or fewer inputs are present on the connected device. [FINGERPRINTING-GUIDANCE]

When a gamepad becomes available on the system, run the following steps:

Let document be the current global object's associated Document; otherwise null.
If document is not null and is not allowed to use the "gamepad" permission, then abort these steps.
Queue a task on the gamepad task source to perform the following steps:
1. Let gamepad be a new Gamepad representing the gamepad.
2. Let navigator be gamepad's relevant global object's Navigator object.
3. Set navigator.[[gamepads]][gamepad.index] to gamepad.
4. If navigator.[[hasGamepadGesture]] is true:
  1. Set gamepad.[[exposed]] to true.
  2. If document is not null and is fully active, then fire an event named gamepadconnected at gamepad's relevant global object using GamepadEvent with its gamepad attribute initialized to gamepad.

User agents implementing this specification must provide a new DOM event, named gamepadconnected. The corresponding event MUST be of type GamepadEvent and MUST fire on the Window object.

A user agent MUST dispatch this event type to indicate the user has connected a gamepad. If a gamepad was already connected when the page was loaded, the gamepadconnected event SHOULD be dispatched when the user presses a button or moves an axis.

When a gamepad becomes unavailable on the system, run the following steps:

Let gamepad be the Gamepad representing the unavailable device.
Queue a task on the gamepad task source to perform the following steps:
1. Set gamepad.[[connected]] to false.
2. Let document be gamepad's relevant global object's associated Document; otherwise null.
3. If gamepad.[[exposed]] is true and document is not null and is fully active, then fire an event named gamepaddisconnected at gamepad's relevant global object using GamepadEvent with its gamepad attribute initialized to gamepad.
4. Let navigator be gamepad's relevant global object's Navigator object.
5. Set navigator.[[gamepads]][gamepad.index] to null.
6. While navigator.[[gamepads]] is not empty and the last item of navigator.[[gamepads]] is null, remove the last item of navigator.[[gamepads]].

User agents implementing this specification must provide a new DOM event, named gamepaddisconnected. The corresponding event MUST be of type GamepadEvent and MUST fire on the Window object.

When a gamepad is disconnected from the user agent, if the user agent has previously dispatched a gamepadconnected event for that gamepad to a Window, a gamepaddisconnected event MUST be dispatched to that same Window.

More discussion needed, on whether to include or exclude axis and button changed events, and whether to roll them more together ("gamepadchanged"?), separate somewhat ("gamepadaxischanged"?), or separate by individual axis and button.

This specification extends the WindowEventHandlers interface mixin from HTML to add event handler IDL attributes to facilitate the event handler registration.

WebIDLpartial interface mixin WindowEventHandlers {   attribute EventHandler ongamepadconnected;   attribute EventHandler ongamepaddisconnected; };

This specification defines a policy-controlled feature identified by the string "gamepad". Its default allowlist is *.

Note

A document’s permissions policy determines whether any content in that document is allowed to access getGamepads(). If disabled in any document, no content in the document will be allowed to use getGamepads(), nor will the gamepadconnected and gamepaddisconnected events fire.

As well as sections marked as non-normative, all authoring guidelines, diagrams, examples, and notes in this specification are non-normative. Everything else in this specification is normative.

The key words MAY, MUST, MUST NOT, RECOMMENDED, SHOULD, and SHOULD NOT in this document are to be interpreted as described in BCP 14 [RFC2119] [RFC8174] when, and only when, they appear in all capitals, as shown here.

[dom]: DOM Standard. Anne van Kesteren. WHATWG. Living Standard. URL: https://dom.spec.whatwg.org/
[FINGERPRINTING-GUIDANCE]: Mitigating Browser Fingerprinting in Web Specifications. Nick Doty. W3C. 28 March 2019. W3C Working Group Note. URL: https://www.w3.org/TR/fingerprinting-guidance/
[geometry-1]: Geometry Interfaces Module Level 1. Simon Pieters; Chris Harrelson. W3C. 4 December 2018. W3C Candidate Recommendation. URL: https://www.w3.org/TR/geometry-1/
[HR-TIME]: High Resolution Time. Yoav Weiss. W3C. 7 November 2024. W3C Working Draft. URL: https://www.w3.org/TR/hr-time-3/
[html]: HTML Standard. Anne van Kesteren; Domenic Denicola; Dominic Farolino; Ian Hickson; Philip Jägenstedt; Simon Pieters. WHATWG. Living Standard. URL: https://html.spec.whatwg.org/multipage/
[infra]: Infra Standard. Anne van Kesteren; Domenic Denicola. WHATWG. Living Standard. URL: https://infra.spec.whatwg.org/
[permissions-policy]: Permissions Policy. Ian Clelland. W3C. 10 February 2025. W3C Working Draft. URL: https://www.w3.org/TR/permissions-policy-1/
[RFC2119]: Key words for use in RFCs to Indicate Requirement Levels. S. Bradner. IETF. March 1997. Best Current Practice. URL: https://www.rfc-editor.org/rfc/rfc2119
[RFC8174]: Ambiguity of Uppercase vs Lowercase in RFC 2119 Key Words. B. Leiba. IETF. May 2017. Best Current Practice. URL: https://www.rfc-editor.org/rfc/rfc8174
[WEBIDL]: Web IDL Standard. Edgar Chen; Timothy Gu. WHATWG. Living Standard. URL: https://webidl.spec.whatwg.org/
[webxr-gamepads-module-1]: WebXR Gamepads Module - Level 1. Brandon Jones; Manish Goregaokar; Rik Cabanier. W3C. 9 April 2024. W3C Working Draft. URL: https://www.w3.org/TR/webxr-gamepads-module-1/

Gamepad

Abstract

Status of This Document

1. Introduction

2. Scope

3. `Gamepad` interface

3.1 Receiving inputs

3.2 Constructing a `Gamepad`

4. `GamepadButton` Interface

5. `GamepadTouch` Interface

6. `GamepadMappingType` enum

7. `GamepadHapticActuator` Interface

7.1 Handling visibility change

7.2 Constructing a `GamepadHapticActuator`

8. `GamepadHapticsResult` Enum

9. `GamepadHapticEffectType` enum

10. `GamepadEffectParameters` Dictionary

11. Extensions to the `Navigator` interface

11.1 `getGamepads()` method

12. `GamepadEvent` Interface

12.1 `GamepadEventInit` dictionary

13. Remapping

13.1 Fingerprinting mitigation

14. Usage Examples

15. The gamepadconnected event

16. The gamepaddisconnected event

17. Other events

18. Extensions to the `WindowEventHandlers` Interface Mixin

19. Integration with Permissions Policy

20. Conformance

A. Acknowledgements

B. References

B.1 Normative references

Gamepad

Abstract

Status of This Document

1. Introduction

2. Scope

3. Gamepad interface

3.1 Receiving inputs

3.2 Constructing a Gamepad

4. GamepadButton Interface

5. GamepadTouch Interface

6. GamepadMappingType enum

7. GamepadHapticActuator Interface

7.1 Handling visibility change

7.2 Constructing a GamepadHapticActuator

8. GamepadHapticsResult Enum

9. GamepadHapticEffectType enum

10. GamepadEffectParameters Dictionary

11. Extensions to the Navigator interface

11.1 getGamepads() method

12. GamepadEvent Interface

12.1 GamepadEventInit dictionary

13. Remapping

13.1 Fingerprinting mitigation

14. Usage Examples

15. The gamepadconnected event

16. The gamepaddisconnected event

17. Other events

18. Extensions to the WindowEventHandlers Interface Mixin

19. Integration with Permissions Policy

20. Conformance

A. Acknowledgements

B. References

B.1 Normative references

3. `Gamepad` interface

3.2 Constructing a `Gamepad`

4. `GamepadButton` Interface

5. `GamepadTouch` Interface

6. `GamepadMappingType` enum

7. `GamepadHapticActuator` Interface

7.2 Constructing a `GamepadHapticActuator`

8. `GamepadHapticsResult` Enum

9. `GamepadHapticEffectType` enum

10. `GamepadEffectParameters` Dictionary

11. Extensions to the `Navigator` interface

11.1 `getGamepads()` method

12. `GamepadEvent` Interface

12.1 `GamepadEventInit` dictionary

18. Extensions to the `WindowEventHandlers` Interface Mixin