The
Gamepad
specification
defines
a
low-level
interface
that
represents
gamepad
devices.
Status
of
This
Document
This
is
a
preview
Do
not
attempt
to
implement
this
version
of
the
specification.
Do
not
reference
this
version
as
authoritative
in
any
way.
Instead,
see
https://w3c.github.io/gamepad/
for
the
Editor's
draft.
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
standards
and
drafts
index
.
Publication
as
an
Editor's
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.
Some
user
agent
s
have
connected
gamepad
devices.
These
devices
are
desirable
and
suited
to
input
for
gaming
applications,
and
for
"10
foot"
user
interfaces
(presentations,
media
viewers).
Currently,
the
only
way
for
a
gamepad
to
be
used
as
input
would
be
to
emulate
mouse
or
keyboard
events,
however
this
would
lose
information
and
require
additional
software
outside
of
the
user
agent
to
accomplish
emulation.
Meanwhile,
native
applications
are
capable
of
accessing
these
devices
via
system
APIs.
The
Gamepad
API
provides
a
solution
to
this
problem
by
specifying
interfaces
that
allow
web
applications
to
directly
act
on
gamepad
data.
2.
Scope
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.
3.
Model
A
gamepad
is
a
collection
of
input
controls
and
output
controls.
An
input
control
has
a
collection
of
input
values
that
may
update
over
time.
Input
controls
include
the
buttons,
triggers,
joysticks,
thumbsticks,
and
touch
surfaces
of
the
gamepad
.
An
output
control
is
a
feature
that
changes
the
behavior
of
the
gamepad
to
provide
feedback
to
the
user
interacting
with
the
gamepad
.
Output
controls
include
the
haptic
actuators
of
the
gamepad
.
A
gamepad
is
available
if
the
user
agent
can
read
the
current
state
of
its
input
controls
.
A
gamepad
that
is
not
available
is
unavailable
.
The
input
controls
and
output
controls
for
a
gamepad
cannot
change
while
the
gamepad
is
available
.
A
gamepad
has
a
gamepad
identifier
string
,
a
human-readable
string
that
identifies
the
brand
or
style
of
gamepad
.
The
content
is
decided
by
the
user
agent
.
3.1
Input
control
layout
A
gamepad
may
have
an
input
control
layout
that
describes
the
position,
orientation
and
type
of
each
input
control
on
the
gamepad
.
The
user
agent
is
responsible
for
recognizing
when
a
gamepad
corresponds
with
a
standard
layout
,
meaning
the
gamepad
has
an
input
control
layout
that
enables
it
to
be
used
interchangeably
with
other
gamepads
that
correspond
with
the
same
standard
layout.
The
user
agent
SHOULD
consider
a
layout
to
correspond
with
a
standard
layout
if
its
input
controls
have
approximately
the
same
relative
positions
and
orientations
as
input
controls
described
in
the
standard
layout.
An
accessible
gamepad
model
is
a
gamepad
where
the
manufacturer's
intent
is
to
provide
a
swap-in
replacement
for
a
gamepad
with
a
standard
layout.
For
example,
Xbox
Adaptive
Controller
and
PlayStation
Access
Controller
are
accessible
gamepad
models.
Xbox
Wireless
Controller
and
DualSense
are
the
corresponding
standard
models.
3.2
Input
values
Each
input
control
has
one
or
more
associated
input
values
,
which
are
numerical
values
that
represent
the
current
state
of
the
control.
Input
values
can
update
at
any
time.
The
user
agent
is
responsible
for
detecting
when
input
values
have
updated
and
SHOULD
try
to
minimize
the
delay
between
the
update
and
when
the
updated
values
are
read.
Reading
an
input
value
returns
its
logical
value
,
an
unscaled
numerical
representation
of
the
current
state.
An
input
value
also
has
a
logical
minimum
and
logical
maximum
which
define
the
minimum
and
maximum
in-bounds
logical
values
.
An
input
control
may
be
designed
to
automatically
return
a
button
to
an
unpressed
state
when
the
user
stops
interacting
with
the
input
control
.
If
so,
the
button
has
a
preferred
button
state
.
A
button
may
have
a
digital
switch
to
indicate
when
the
button
is
activated.
If
so,
the
button
has
an
additional
input
value
,
the
digital
button
value
,
that
is
true
when
the
button
is
activated
and
false
otherwise.
A
button
may
have
an
analog
sensor
enabling
the
button
to
report
the
degree
to
which
the
button
is
activated.
If
so,
the
button
has:
An
analog
button
value
,
a
logical
value
that
represents
the
degree
of
activation,
A
button
may
be
capable
of
detecting
touch.
If
so,
the
button
has
an
additional
input
value
,
the
button
touch
value
,
that
is
true
when
the
button
is
touched
and
false
otherwise.
A
touch
surface
has
an
active
touch
point
list
input
value
,
a
list
of
zero
or
more
touch
points
representing
the
points
of
contact
currently
detected
by
the
sensor.
A
touch
point
represents
a
single
point
of
contact
at
a
single
point
in
time.
A
touch
point
has
a
touch
x
coordinate
and
a
touch
y
coordinate
representing
the
position
in
the
touch
surface
's
coordinate
system.
If
a
touch
surface
is
on
the
top,
bottom,
front,
or
back
side
of
the
gamepad
then
the
touch
x
coordinate
is
measured
along
the
left-right
axis,
otherwise
it
is
measured
along
the
top-bottom
axis.
The
touch
y
coordinate
is
measured
along
the
perpendicular
axis.
If
a
touch
surface
is
on
the
left
or
right
side
of
a
gamepad
then
neither
of
its
dimensions
will
align
with
the
horizontal
axis.
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.
vendorId
attribute
The
16-bit
identifier
assigned
to
the
device
vendor
by
the
USB
Implementers
Forum
or
Bluetooth
Special
Interest
Group,
or
null
if
the
gamepad
has
no
vendor
identifier
or
it
is
not
available.
The
product
identifier
assigned
by
the
device
vendor,
or
null
if
the
gamepad
has
no
product
identifier
or
it
is
not
available.
name
attribute
A
human-readable
identifier
for
the
gamepad.
The
exact
content
of
the
name
string
is
left
unspecified.
The
user
agent
MAY
use
a
product
name
string
provided
by
the
device
firmware.
The
name
MUST
NOT
be
the
empty
string
and
MUST
NOT
include
unique
identifiers
like
serial
numbers
or
Bluetooth
device
addresses.
Note
The
name
is
intended
only
as
a
user-facing
identifier.
It
is
not
a
stable
identifier
and
might
change
over
time
due
to
updates
to
the
device
firmware,
browser,
or
operating
system.
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
.
User
agent
s
SHOULD
set
a
minimum
resolution
of
gamepad
's
timestamp
attribute
to
5
microseconds,
following
[
HR-TIME
]'s
clock
resolution
recommendation.
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).
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).
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.
Let
normalizedValue
be
2
(
logicalValue
−
logicalMinimum
)
/
(
logicalMaximum
−
logicalMinimum
)
−
1.
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.
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.
Repeat
the
following
steps
for
each
touch
surface
on
gamepad
in
touch
surface
enumeration
order:
Let
surfaceId
be
the
current
surface
enumeration
index.
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.
Repeat
the
following
steps
for
each
active
touch
point
reported
by
the
gamepad
for
the
current
touch
surface.
If
the
touch
data
is
part
of
an
existing
active
touch
point
tracked
by
the
user
agent:
Set
touch
.
touchId
to
the
touchId
of
the
active
touch
point.
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.
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
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
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.
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.
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.
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.
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.
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.
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
.
"
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.
strongMagnitude
and
weakMagnitude
set
the
intensity
levels
for
the
low-frequency
and
high-frequency
vibrations,
normalized
to
the
range
[0,1]
,
defaulting
to
0.
"
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
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.
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.
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.
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)
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
]
15.
Usage
Examples
This
section
is
non-normative.
The
example
below
demonstrates
typical
access
to
gamepads.
Note
the
relationship
with
the
requestAnimationFrame
()
method.
functionrunAnimation() {
window.requestAnimationFrame(runAnimation);
for (const pad of navigator.getGamepads()) {
// todo; simple demo of displaying pad.axes and pad.buttonsconsole.log(pad);
}
}
window
.
requestAnimationFrame
(runAnimation);
Interactive
applications
will
typically
be
using
the
requestAnimationFrame
()
method
to
drive
animation,
and
will
want
coordinate
animation
with
user
gamepad
input.
As
such,
the
gamepad
data
should
be
polled
as
closely
as
possible
to
immediately
before
the
animation
callbacks
are
executed,
and
with
frequency
matching
that
of
the
animation.
That
is,
if
the
animation
callbacks
are
running
at
60Hz,
the
gamepad
inputs
should
also
be
sampled
at
that
rate.
16.
The
gamepadconnected
event
When
a
gamepad
becomes
available
on
the
system,
run
the
following
steps:
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.
17.
The
gamepaddisconnected
event
When
a
gamepad
becomes
unavailable
on
the
system,
run
the
following
steps:
Let
gamepad
be
the
Gamepad
representing
the
unavailable
device.
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.
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.
19.
Extensions
to
the
WindowEventHandlers
Interface
Mixin
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.
A.
Acknowledgements
This
section
is
non-normative.
The
following
people
contributed
to
the
development
of
this
document.
