Struct Gamepad 

#[repr(C)]
pub(crate) struct Gamepad {

    reflector_: Reflector,
    gamepad_id: u32,
    id: String,
    index: Cell<i32>,
    connected: Cell<bool>,
    timestamp: Cell<f64>,
    mapping_type: String,
    frozen_buttons: CachedFrozenArray,
    buttons: Vec<Dom<GamepadButton>>,
    frozen_axes: CachedFrozenArray,
    axes: RefCell<Vec<f64>>,
    pose: Option<Dom<GamepadPose>>,
    hand: GamepadHand,
    axis_bounds: (f64, f64),
    button_bounds: (f64, f64),
    exposed: Cell<bool>,
    vibration_actuator: Dom<GamepadHapticActuator>,
}

Fields

reflector_: Reflector

gamepad_id: u32

id: String

index: Cell<i32>

connected: Cell<bool>

timestamp: Cell<f64>

mapping_type: String

frozen_buttons: CachedFrozenArray

buttons: Vec<Dom<GamepadButton>>

frozen_axes: CachedFrozenArray

axes: RefCell<Vec<f64>>

pose: Option<Dom<GamepadPose>>

hand: GamepadHand

axis_bounds: (f64, f64)

button_bounds: (f64, f64)

exposed: Cell<bool>

vibration_actuator: Dom<GamepadHapticActuator>

Implementations

impl Gamepad

fn __assert_parent_type(&self)

impl Gamepad

fn new_inherited( gamepad_id: u32, id: String, index: i32, connected: bool, timestamp: f64, mapping_type: String, buttons: &[&GamepadButton], pose: Option<&GamepadPose>, hand: GamepadHand, axis_bounds: (f64, f64), button_bounds: (f64, f64), vibration_actuator: &GamepadHapticActuator, ) -> Gamepad

pub(crate) fn new( cx: &mut JSContext, window: &Window, gamepad_id: u32, id: String, mapping_type: String, axis_bounds: (f64, f64), button_bounds: (f64, f64), supported_haptic_effects: GamepadSupportedHapticEffects, xr: bool, ) -> DomRoot<Gamepad>

From: https://www.w3.org/TR/gamepad/#fingerprinting-mitigation 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.

So, we initialize the number of buttons and axes corresponding to the “standard” gamepad mapping and happens to simplify implementation. https://www.w3.org/TR/gamepad/#dfn-a-new-gamepad

impl Gamepad

pub(crate) fn gamepad_id(&self) -> u32

fn init_buttons( cx: &mut JSContext, window: &Window, ) -> Vec<DomRoot<GamepadButton>>

Initialize the standard buttons for a gamepad. https://www.w3.org/TR/gamepad/#dfn-initializing-buttons

pub(crate) fn update_connected(&self, connected: bool)

pub(crate) fn index(&self) -> i32

pub(crate) fn update_index(&self, index: i32)

pub(crate) fn update_timestamp(&self, timestamp: f64)

pub(crate) fn notify_event( &self, cx: &mut JSContext, event_type: GamepadEventType, )

fn init_axes(&self)

Initialize the number of axes in the “standard” gamepad mapping. https://www.w3.org/TR/gamepad/#dfn-initializing-axes

pub(crate) fn map_and_normalize_axes(&self, axis_index: usize, value: f64)

https://www.w3.org/TR/gamepad/#dfn-map-and-normalize-axes

pub(crate) fn map_and_normalize_buttons(&self, button_index: usize, value: f64)

https://www.w3.org/TR/gamepad/#dfn-map-and-normalize-buttons

pub(crate) fn connected(&self) -> bool

pub(crate) fn exposed(&self) -> bool

https://www.w3.org/TR/gamepad/#dfn-exposed

pub(crate) fn set_exposed(&self, exposed: bool)

https://www.w3.org/TR/gamepad/#dfn-exposed

pub(crate) fn vibration_actuator(&self) -> &GamepadHapticActuator

Trait Implementations

impl DomObject for Gamepad

type ReflectorType = ()

fn reflector(&self) -> &Reflector<Self::ReflectorType>

Returns the receiver’s reflector.

impl DomObjectWrap<DomTypeHolder> for Gamepad

const WRAP: unsafe fn(&mut JSContext, &GlobalScope, Option<HandleObject<'_>>, Box<Self>) -> Root<Dom<Self>>

Function pointer to the general wrap function type

impl Drop for Gamepad

fn drop(&mut self)

Executes the destructor for this type.

impl GamepadMethods<DomTypeHolder> for Gamepad

fn Id(&self) -> DOMString

https://w3c.github.io/gamepad/#dom-gamepad-id

fn Index(&self) -> i32

https://w3c.github.io/gamepad/#dom-gamepad-index

fn Connected(&self) -> bool

https://w3c.github.io/gamepad/#dom-gamepad-connected

fn Timestamp(&self) -> Finite<f64>

https://w3c.github.io/gamepad/#dom-gamepad-timestamp

fn Mapping(&self) -> DOMString

https://w3c.github.io/gamepad/#dom-gamepad-mapping

fn Axes(&self, cx: &mut JSContext, retval: MutableHandleValue<'_>)

https://w3c.github.io/gamepad/#dom-gamepad-axes

fn Buttons(&self, cx: &mut JSContext, retval: MutableHandleValue<'_>)

https://w3c.github.io/gamepad/#dom-gamepad-buttons

fn VibrationActuator(&self) -> DomRoot<GamepadHapticActuator>

https://w3c.github.io/gamepad/#dom-gamepad-vibrationactuator

fn Hand(&self) -> GamepadHand

https://w3c.github.io/gamepad/extensions.html#gamepadhand-enum

fn GetPose(&self) -> Option<DomRoot<GamepadPose>>

https://w3c.github.io/gamepad/extensions.html#dom-gamepad-pose

impl HasParent for Gamepad

fn as_parent(&self) -> &Reflector

This is used in a type assertion to ensure that the source and webidls agree as to what the parent type is

type Parent = Reflector

impl IDLInterface for Gamepad

const PROTO_FIRST: u16 = 388

First prototype ID in the DFS-ordered range for this interface and its descendants.

const PROTO_LAST: u16 = 388

Last prototype ID in the DFS-ordered range for this interface and its descendants.

fn derives(class: &'static DOMClass) -> bool

Returns whether the given DOM class derives that interface.

impl MallocSizeOf for Gamepad

fn size_of(&self, ops: &mut MallocSizeOfOps) -> usize

Measure the heap usage of all descendant heap-allocated structures, but not the space taken up by the value itself.

impl MutDomObject for Gamepad

unsafe fn init_reflector<Actual>(&self, obj: *mut JSObject)

Initializes the Reflector

unsafe fn init_reflector_without_associated_memory(&self, obj: *mut JSObject)

Initializes the Reflector without recording any associated memory usage.

impl PartialEq for Gamepad

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl ToJSValConvertible for Gamepad

unsafe fn to_jsval(&self, cx: *mut JSContext, rval: MutableHandleValue<'_>)

Convert self to a JSVal. JSAPI failure causes a panic.

fn safe_to_jsval(&self, cx: &mut JSContext, rval: MutableHandle<'_, Value>)

Convert self to a JSVal. JSAPI failure causes a panic.

impl Traceable for Gamepad

unsafe fn trace(&self, tracer: *mut JSTracer)

Trace self.

impl Eq for Gamepad