This specification extends the Gamepad API’s GamepadHapticActuator interface with the ability to play PCM audio data as haptic feedback.
Status of this document
This section describes the status of this document at the time of its publication. A list of current
W3C publications and the latest revision of this
technical report can be found in the
W3C technical
reports index at http://www.w3.org/TR/.
Publication as an Editors' Draft does not imply endorsement by
W3C and its Members. This is a draft document and may
be updated, replaced, or obsoleted by other documents at any time. It is inappropriate to cite
this document as other than a work in progress.
This document was produced by a group operating under the
W3C Patent Policy.
W3C maintains a public list of any patent
disclosures made in connection with the deliverables of the group; that page also includes instructions for disclosing a patent. An individual who has actual knowledge of a patent that the individual believes contains
Essential
Claim(s) must disclose the information in accordance with
section
6 of the W3C Patent Policy.
Some gamepad devices include haptic actuators capable of rendering audio waveforms directly to the user as haptic feedback. This specification extends the GamepadHapticActuator interface defined in the Gamepad specification with the play() method, which allows authors to play PCM audio data from an AudioBuffer through the gamepad’s haptic actuators.
This enables richer haptic experiences than predefined effects, as developers can design custom waveforms using the Web Audio API and play them through the gamepad’s haptic hardware.
NOTE: The sampleRate of the AudioBuffer may not match the native sample rate of the haptic actuator. In this case, the user agent SHOULD resample the audio data to match the actuator’s native sample rate.
Playing a custom haptic waveform from an AudioBuffer:
const audioCtx =new AudioContext();const sampleRate = audioCtx.sampleRate;const buffer = audioCtx.createBuffer(1, sampleRate *0.5, sampleRate);// Fill with a 150Hz sine wave for 0.5 secondsconst channelData = buffer.getChannelData(0);for(let i =0; i < buffer.length; i++){
channelData[i]= Math.sin(2* Math.PI *150* i / sampleRate);}const gamepad = navigator.getGamepads()[0];const success =await gamepad.vibrationActuator.play(buffer);if(success){
console.log("Haptic waveform played successfully");}else{
console.log("PCM haptic playback failed or is not supported");}
3. Security and Privacy Considerations
This specification does not introduce any new security or privacy considerations beyond those described in the Gamepad and Web Audio API specifications.
The play() method requires the same user activation and visibility conditions as the existing playEffect() method to prevent abuse of haptic hardware by background pages.
Conformance
Document conventions
Conformance requirements are expressed
with a combination of descriptive assertions
and RFC 2119 terminology.
The key words “MUST”, “MUST NOT”, “REQUIRED”, “SHALL”, “SHALL NOT”, “SHOULD”, “SHOULD NOT”, “RECOMMENDED”, “MAY”, and “OPTIONAL”
in the normative parts of this document
are to be interpreted as described in RFC 2119.
However, for readability,
these words do not appear in all uppercase letters in this specification.
All of the text of this specification is normative
except sections explicitly marked as non-normative, examples, and notes. [RFC2119]
Examples in this specification are introduced with the words “for example”
or are set apart from the normative text
with class="example",
like this:
This is an example of an informative example.
Informative notes begin with the word “Note”
and are set apart from the normative text
with class="note",
like this:
Note, this is an informative note.
Conformant Algorithms
Requirements phrased in the imperative as part of algorithms
(such as "strip any leading space characters"
or "return false and abort these steps")
are to be interpreted with the meaning of the key word
("must", "should", "may", etc)
used in introducing the algorithm.
Conformance requirements phrased as algorithms or specific steps
can be implemented in any manner,
so long as the end result is equivalent.
In particular, the algorithms defined in this specification
are intended to be easy to understand
and are not intended to be performant.
Implementers are encouraged to optimize.