README
U
Code
E
DistanceModelError
E
FfError
- ::is_invalid_axis_to_btnGilError::is_invalid_axis_to_btn
- ::invalid_codeMappingError::invalid_code
E
ParseSdlMappingError
- ::kindParserError::kind
- ::positionParserError::position
E
UuidError
- ::is_stickAxis::is_stick
- ::second_axisAxis::second_axis
- ::to_indexAxis::to_index
- ::counterAxisData::counter
- ::timestampAxisData::timestamp
- ::valueAxisData::value
- ::newAxisInfo::new
- ::is_buttonAxisOrBtn::is_button
T
AxisRange
T
BackendOwner
- ::defaultBaseEffect::default
T
BaseEffectType
- ::is_actionButton::is_action
- ::is_dpadButton::is_dpad
- ::is_menuButton::is_menu
- ::is_stickButton::is_stick
- ::is_triggerButton::is_trigger
- ::to_indexButton::to_index
- ::counterButtonData::counter
- ::is_pressedButtonData::is_pressed
- ::is_repeatingButtonData::is_repeating
- ::timestampButtonData::timestamp
- ::valueButtonData::value
- ::validateDistanceModel::validate
- ::add_gamepadEffect::add_gamepad
- ::playEffect::play
- ::set_distance_modelEffect::set_distance_model
- ::set_gainEffect::set_gain
- ::set_gamepadsEffect::set_gamepads
- ::set_positionEffect::set_position
- ::set_repeatEffect::set_repeat
- ::stopEffect::stop
- ::add_effectEffectBuilder::add_effect
- ::add_gamepadEffectBuilder::add_gamepad
- ::add_gamepad_idEffectBuilder::add_gamepad_id
- ::distance_modelEffectBuilder::distance_model
- ::durationEffectBuilder::duration
- ::finishEffectBuilder::finish
- ::gainEffectBuilder::gain
- ::gamepadsEffectBuilder::gamepads
- ::newEffectBuilder::new
- ::positionEffectBuilder::position
- ::repeatEffectBuilder::repeat
- ::rumbleEffectBuilder::rumble
- ::atEnvelope::at
- ::defaultEnvelope::default
- ::atEvent::at
- ::dropEvent::drop
- ::eventEvent::event
- ::idEvent::id
- ::is_droppedEvent::is_dropped
- ::newEvent::new
- ::timeEvent::time
T
EventType
T
FfEffectSource
T
FfRepeat
- ::axesGamepad::axes
- ::axis_codeGamepad::axis_code
- ::axis_dataGamepad::axis_data
- ::axis_infoGamepad::axis_info
- ::axis_or_btn_nameGamepad::axis_or_btn_name
- ::button_codeGamepad::button_code
- ::button_dataGamepad::button_data
- ::buttonsGamepad::buttons
- ::deadzoneGamepad::deadzone
- ::idGamepad::id
- ::is_connectedGamepad::is_connected
- ::is_ff_supportedGamepad::is_ff_supported
- ::is_pressedGamepad::is_pressed
- ::map_nameGamepad::map_name
- ::mappingGamepad::mapping
- ::mapping_sourceGamepad::mapping_source
- ::nameGamepad::name
- ::os_nameGamepad::os_name
- ::power_infoGamepad::power_info
- ::product_idGamepad::product_id
- ::set_listener_positionGamepad::set_listener_position
- ::stateGamepad::state
- ::uuidGamepad::uuid
- ::valueGamepad::value
- ::vendor_idGamepad::vendor_id
T
GamepadData
- ::GamepadIdGamepadId::GamepadId
- ::newGamepadId::new
- ::valueGamepadId::value
- ::axes_entriesGamepadState::axes_entries
- ::axis_dataGamepadState::axis_data
- ::button_dataGamepadState::button_data
- ::buttons_entriesGamepadState::buttons_entries
- ::is_pressedGamepadState::is_pressed
- ::newGamepadState::new
- ::valueGamepadState::value
- ::axis_codeGil::axis_code
- ::axis_or_btn_nameGil::axis_or_btn_name
- ::button_codeGil::button_code
- ::connected_gamepadGil::connected_gamepad
- ::counterGil::counter
- ::deadzoneGil::deadzone
- ::default_filters_enabledGil::default_filters_enabled
- ::gamepadGil::gamepad
- ::gamepadsGil::gamepads
- ::incGil::inc
- ::insert_eventGil::insert_event
- ::is_connectedGil::is_connected
- ::load_mappingsGil::load_mappings
- ::mappingGil::mapping
- ::newGil::new
- ::new_mockGil::new_mock
- ::new_nativeGil::new_native
- ::next_eventGil::next_event
- ::next_event_blockingGil::next_event_blocking
- ::pollGil::poll
- ::reset_counterGil::reset_counter
- ::set_axis_to_btnGil::set_axis_to_btn
- ::set_deadzoneGil::set_deadzone
- ::set_mappingGil::set_mapping
- ::set_mapping_dataGil::set_mapping_data
- ::set_mapping_data_strictGil::set_mapping_data_strict
- ::set_timeGil::set_time
- ::stateGil::state
- ::timeGil::time
- ::updateGil::update
- ::update_state_enabledGil::update_state_enabled
- ::with_default_filtersGil::with_default_filters
- ::add_env_mappingsGilBuilder::add_env_mappings
- ::add_included_mappingsGilBuilder::add_included_mappings
- ::add_mappingsGilBuilder::add_mappings
- ::buildGilBuilder::build
- ::newGilBuilder::new
- ::set_axis_to_btnGilBuilder::set_axis_to_btn
- ::set_update_stateGilBuilder::set_update_state
- ::with_default_filtersGilBuilder::with_default_filters
- ::with_mock_gamepad_countGilBuilder::with_mock_gamepad_count
- ::with_native_backendGilBuilder::with_native_backend
- ::filterJitter::filter
- ::newJitter::new
- ::entriesMapping::entries
- ::from_dataMapping::from_data
- ::hats_mappedMapping::hats_mapped
- ::insertMapping::insert
- ::is_defaultMapping::is_default
- ::mapMapping::map
- ::map_revMapping::map_rev
- ::nameMapping::name
- ::newMapping::new
- ::new_defaultMapping::new_default
- ::parse_sdl_mappingMapping::parse_sdl_mapping
- ::set_hats_mappedMapping::set_hats_mapped
- ::axisMappingData::axis
- ::buttonMappingData::button
- ::insert_axisMappingData::insert_axis
- ::insert_btnMappingData::insert_btn
- ::newMappingData::new
- ::remove_axisMappingData::remove_axis
- ::remove_buttonMappingData::remove_button
- ::add_env_mappingsMappingDb::add_env_mappings
- ::add_included_mappingsMappingDb::add_included_mappings
- ::getMappingDb::get
- ::insertMappingDb::insert
- ::lenMappingDb::len
- ::newMappingDb::new
T
MappingSource
- ::axesNativeBackend::axes
- ::axis_infoNativeBackend::axis_info
- ::buttonsNativeBackend::buttons
- ::gamepad_countNativeBackend::gamepad_count
- ::is_connectedNativeBackend::is_connected
- ::is_ff_supportedNativeBackend::is_ff_supported
- ::last_gamepad_hintNativeBackend::last_gamepad_hint
- ::nameNativeBackend::name
- ::newNativeBackend::new
- ::next_eventNativeBackend::next_event
- ::pollNativeBackend::poll
- ::poll_timeoutNativeBackend::poll_timeout
- ::power_infoNativeBackend::power_info
- ::product_idNativeBackend::product_id
- ::set_rumbleNativeBackend::set_rumble
- ::uuid_simpleNativeBackend::uuid_simple
- ::vendor_idNativeBackend::vendor_id
T
NativeEvent
T
NativeEventTag
T
ParserErrorKind
T
PowerInfo
- ::filterRepeat::filter
- ::newRepeat::new
- ::atReplay::at
- ::defaultReplay::default
- ::durReplay::dur
- ::as_msTicks::as_ms
- ::from_msTicks::from_ms
T
Token
- ::nilUuid::nil
- ::parseUuid::parse
- ::simpleUuid::simple
V
AXIS_COUNT
V
AXIS_DPADX
V
AXIS_DPADY
V
AXIS_LEFTZ
V
AXIS_LSTICKX
V
AXIS_LSTICKY
V
AXIS_LT
V
AXIS_LT2
V
AXIS_RIGHTZ
V
AXIS_RSTICKX
V
AXIS_RSTICKY
V
AXIS_RT
V
AXIS_RT2
V
BTN_C
V
BTN_DPAD_DOWN
V
BTN_DPAD_LEFT
V
BTN_DPAD_RIGHT
V
BTN_DPAD_UP
V
BTN_EAST
V
BTN_LT
V
BTN_LT2
V
BTN_LTHUMB
V
BTN_MODE
V
BTN_NORTH
V
BTN_RT
V
BTN_RT2
V
BTN_RTHUMB
V
BTN_SELECT
V
BTN_SOUTH
V
BTN_START
V
BTN_WEST
V
BTN_Z
V
BUTTON_COUNT
V
LEGACY_AXIS_DPADX
V
LEGACY_AXIS_DPADY
V
LEGACY_AXIS_LEFTZ
V
LEGACY_AXIS_LSTICKX
V
LEGACY_AXIS_LSTICKY
V
LEGACY_AXIS_LT
V
LEGACY_AXIS_LT2
V
LEGACY_AXIS_RIGHTZ
V
LEGACY_AXIS_RSTICKX
V
LEGACY_AXIS_RSTICKY
V
LEGACY_AXIS_RT
V
LEGACY_AXIS_RT2
V
LEGACY_BTN_C
V
LEGACY_BTN_DPAD_DOWN
V
LEGACY_BTN_DPAD_LEFT
V
LEGACY_BTN_DPAD_RIGHT
V
LEGACY_BTN_DPAD_UP
V
LEGACY_BTN_EAST
V
LEGACY_BTN_LT
V
LEGACY_BTN_LT2
V
LEGACY_BTN_LTHUMB
V
LEGACY_BTN_MODE
V
LEGACY_BTN_NORTH
V
LEGACY_BTN_RT
V
LEGACY_BTN_RT2
V
LEGACY_BTN_RTHUMB
V
LEGACY_BTN_SELECT
V
LEGACY_BTN_SOUTH
V
LEGACY_BTN_START
V
LEGACY_BTN_WEST
V
LEGACY_BTN_Z
V
PAGE_BUTTON
V
PAGE_GENERIC_DESKTOP
V
PAGE_SIMULATION
V
axis_dpad_to_button
V
axis_from_code
V
axis_or_btn_from_code
V
axis_value
V
btn_value
V
button_from_code
V
ceil_div
V
clamp
V
deadzone
V
decode_native_event
V
default_axis_code
V
default_button_code
V
filter_ev
V
hid_code
V
hid_page
V
hid_usage
V
jitter
V
runtime_env_sdl_gamecontrollerconfig
V
runtime_now_ms
V
runtime_sdl_platform_name

gamepad

Download zip

Author

Milky2018

Version

0.4.7

License

Apache-2.0

Repository

github.com/moonbit-community/moon_gamepad.git

Last updated

2 months ago

Downloads

#Milky2018/gamepad

Milky2018/gamepad is a MoonBit gamepad input library for native targets. It provides gil-style events, state tracking, SDL controller mappings, input filters, force-feedback APIs, and a mock backend for tests.

#Install

moon add Milky2018/gamepad

Use the native target for real device input:

moon test --target native
moon run --target native

#Platform Support

Best support today is on macOS. Linux and Windows are available on native targets as well.

macOS native backend (IOHIDManager)
Linux native backend (evdev)
Windows native backend (XInput)
Non-native targets for real device input

#Features

Native gamepad discovery and hotplug events
Gil event polling and blocking waits
Per-device state tracking through Gamepad and GamepadState
SDL controller mapping database support, including bundled mappings
Input filters: jitter, deadzone, axis_dpad_to_button, Repeat
Force-feedback APIs with platform-specific backend support
Mock backend for deterministic tests

#API Notes

Errors: Gil::new() does not raise. GilBuilder::build() may raise GilError.
Event time: Event::time() is a millisecond timestamp. On native backends this comes from the OS clock; on the mock backend it is whatever you set in Event::at(...).
Mappings (gil naming): Rust gil re-exports MappingData as Mapping. In this MoonBit port, the user-editable type is MappingData; Mapping is the parsed SDL mapping used by Gil.
Filters: Compose filters with filter_ev. If you write a custom filter, it must not turn Some(event) into None; to drop an event return Some(event.drop()).

#Force Feedback

macOS: not supported (will report is_ff_supported = false).
Linux/Windows: supported when the backend/device supports rumble.

#Quick Start

///|
test "quick start" {
  let gil = Gil::new()

  while true {
    match gil.next_event() {
      None => break
      Some(ev) => ...
    }
  }
}

#Mock Example

///|
test "mock button press" {
  let gil = GilBuilder::new()
    .with_mock_gamepad_count(1)
    .with_default_filters(false)
    .build()

  let id = @gamepad.GamepadId(0)
  gil.insert_event(Event::at(id, ButtonPressed(South, BTN_SOUTH), 0L))

  assert_true(gil.next_event() is Some(_))
}

#Notes

Code values are backend-specific raw input codes.
On macOS, some raw HID axes such as Rx and Ry may need SDL mappings before they resolve to semantic Axis values.
On macOS, PowerInfo currently reports Unknown.
On non-native targets, the package builds with a stub backend and does not provide real device events.
Force-feedback repeat mode is exposed as FfRepeat.

#License

Apache-2.0.

Code

source

type Code = Int

DistanceModelError

source

type DistanceModelError

FfError

source

type FfError

GilError

source

type GilError

GilError::is_invalid_axis_to_btn

source

fn GilError::is_invalid_axis_to_btn(self : GilError) -> Bool

MappingError

source

type MappingError

MappingError::invalid_code

source

fn MappingError::invalid_code(self : MappingError) -> Int?

ParseSdlMappingError

source

type ParseSdlMappingError

ParserError

source

type ParserError

ParserError::kind

source

fn ParserError::kind(self : ParserError) -> ParserErrorKind

ParserError::position

source

fn ParserError::position(self : ParserError) -> Int

UuidError

source

type UuidError

Axis

source

pub(all) enum Axis {
  LeftStickX
  LeftStickY
  LeftZ
  RightStickX
  RightStickY
  RightZ
  DPadX
  DPadY
  Unknown
}

Axis::is_stick

source

fn Axis::is_stick(self : Axis) -> Bool

Axis::second_axis

source

fn Axis::second_axis(self : Axis) -> Axis?

Axis::to_index

source

fn Axis::to_index(self : Axis) -> Int

AxisData

source

pub struct AxisData {
  last_event_ts : Int64
  last_event_c : Int64
  value : Double
}

AxisData::counter

source

fn AxisData::counter(self : AxisData) -> Int64

AxisData::timestamp

source

fn AxisData::timestamp(self : AxisData) -> Int64

AxisData::value

source

fn AxisData::value(self : AxisData) -> Double

AxisInfo

source

pub struct AxisInfo {
  min : Int
  max : Int
  deadzone : Int?
}

AxisInfo::new

source

fn AxisInfo::new(min : Int, max : Int, deadzone : Int?) -> AxisInfo

AxisOrBtn

source

pub(all) enum AxisOrBtn {
  Axis(Axis)
  Btn(Button)
}

AxisOrBtn::is_button

source

fn AxisOrBtn::is_button(self : AxisOrBtn) -> Bool

AxisRange

source

pub(all) enum AxisRange {
  LowerHalf
  UpperHalf
  Full
}

BackendOwner

source

type BackendOwner

BaseEffect

source

pub struct BaseEffect {
  kind : BaseEffectType
  scheduling : Replay
  envelope : Envelope
}

BaseEffect::default

source

fn BaseEffect::default() -> BaseEffect

BaseEffectType

source

pub(all) enum BaseEffectType {
  Weak(Int)
  Strong(Int)
}

Button

source

pub(all) enum Button {
  South
  East
  C
  North
  West
  Z
  LeftTrigger
  RightTrigger
  LeftTrigger2
  RightTrigger2
  Select
  Start
  Mode
  LeftThumb
  RightThumb
  DPadUp
  DPadDown
  DPadLeft
  DPadRight
  Unknown
}

Button::is_action

source

fn Button::is_action(self : Button) -> Bool

Button::is_dpad

source

fn Button::is_dpad(self : Button) -> Bool

Button::is_menu

source

fn Button::is_menu(self : Button) -> Bool

Button::is_stick

source

fn Button::is_stick(self : Button) -> Bool

Button::is_trigger

source

fn Button::is_trigger(self : Button) -> Bool

Button::to_index

source

fn Button::to_index(self : Button) -> Int

ButtonData

source

pub struct ButtonData {
  last_event_ts : Int64
  counter : Int64
  value : Double
  is_pressed : Bool
  is_repeating : Bool
}

ButtonData::counter

source

fn ButtonData::counter(self : ButtonData) -> Int64

ButtonData::is_pressed

source

fn ButtonData::is_pressed(self : ButtonData) -> Bool

ButtonData::is_repeating

source

fn ButtonData::is_repeating(self : ButtonData) -> Bool

ButtonData::timestamp

source

fn ButtonData::timestamp(self : ButtonData) -> Int64

ButtonData::value

source

fn ButtonData::value(self : ButtonData) -> Double

DistanceModel

source

pub enum DistanceModel {
  None
  Linear(ref_distance~ : Double, rolloff_factor~ : Double, max_distance~ : Double)
  LinearClamped(ref_distance~ : Double, rolloff_factor~ : Double, max_distance~ : Double)
  Inverse(ref_distance~ : Double, rolloff_factor~ : Double)
  InverseClamped(ref_distance~ : Double, rolloff_factor~ : Double, max_distance~ : Double)
  Exponential(ref_distance~ : Double, rolloff_factor~ : Double)
  ExponentialClamped(ref_distance~ : Double, rolloff_factor~ : Double, max_distance~ : Double)
}

DistanceModel::validate

source

fn DistanceModel::validate(self : DistanceModel) -> Unit raise DistanceModelError

Effect

source

pub struct Effect {
  gil : Gil
  effect_token : Int
  gamepads : Array[GamepadId]
  strong : Double
  weak : Double
  duration_ms : Int64
  base_effects : Array[BaseEffect]
  repeat_mode : FfRepeat
  distance_model : DistanceModel
  position : (Double, Double, Double)
  gain : Double
  playing_since_ms : Int64?
}

Effect::add_gamepad

source

fn Effect::add_gamepad(self : Effect, gamepad : Gamepad) -> Unit raise FfError

Effect::play

source

fn Effect::play(self : Effect) -> Unit raise FfError

Effect::set_distance_model

source

fn Effect::set_distance_model(self : Effect, model : DistanceModel) -> Unit raise FfError

Effect::set_gain

source

fn Effect::set_gain(self : Effect, gain : Double) -> Unit

Effect::set_gamepads

source

fn Effect::set_gamepads(self : Effect, ids : Array[GamepadId], gil : Gil) -> Unit raise FfError

Effect::set_position

source

fn Effect::set_position(self : Effect, position : (Double, Double, Double)) -> Unit

Effect::set_repeat

source

fn Effect::set_repeat(self : Effect, repeat_mode : FfRepeat) -> Unit

Effect::stop

source

fn Effect::stop(self : Effect) -> Unit raise FfError

EffectBuilder

source

pub struct EffectBuilder {
  gamepads : Array[GamepadId]
  base_effects : Array[BaseEffect]
  repeat_mode : FfRepeat
  distance_model : DistanceModel
  position : (Double, Double, Double)
  gain : Double
  strong : Double
  weak : Double
  duration_ms : Int64
}

EffectBuilder::add_effect

source

fn EffectBuilder::add_effect(self : EffectBuilder, effect : BaseEffect) -> EffectBuilder

EffectBuilder::add_gamepad

source

fn EffectBuilder::add_gamepad(self : EffectBuilder, gamepad : Gamepad) -> EffectBuilder

EffectBuilder::add_gamepad_id

source

fn EffectBuilder::add_gamepad_id(self : EffectBuilder, id : GamepadId) -> EffectBuilder

EffectBuilder::distance_model

source

fn EffectBuilder::distance_model(self : EffectBuilder, model : DistanceModel) -> EffectBuilder

EffectBuilder::duration

source

fn EffectBuilder::duration(self : EffectBuilder, duration_ms : Int64) -> EffectBuilder

EffectBuilder::finish

source

fn EffectBuilder::finish(self : EffectBuilder, gil : Gil) -> Effect raise FfError

EffectBuilder::gain

source

fn EffectBuilder::gain(self : EffectBuilder, gain : Double) -> EffectBuilder

EffectBuilder::gamepads

source

fn EffectBuilder::gamepads(self : EffectBuilder, ids : Array[GamepadId]) -> EffectBuilder

EffectBuilder::new

source

fn EffectBuilder::new() -> EffectBuilder

EffectBuilder::position

source

fn EffectBuilder::position(self : EffectBuilder, position : (Double, Double, Double)) -> EffectBuilder

EffectBuilder::repeat

source

fn EffectBuilder::repeat(self : EffectBuilder, repeat_mode : FfRepeat) -> EffectBuilder

EffectBuilder::rumble

source

fn EffectBuilder::rumble(self : EffectBuilder, strong : Double, weak : Double) -> EffectBuilder

Envelope

source

pub struct Envelope {
  attack_length : Int
  attack_level : Double
  fade_length : Int
  fade_level : Double
}

Envelope::at

source

fn Envelope::at(self : Envelope, ticks : Int, dur : Int) -> Double

Envelope::default

source

fn Envelope::default() -> Envelope

Event

source

pub struct Event {
  id : GamepadId
  event : EventType
  time : Int64
}

Event::at

source

fn Event::at(id : GamepadId, event : EventType, time : Int64) -> Event

Event::drop

source

fn Event::drop(self : Event) -> Event

Event::event

source

fn Event::event(self : Event) -> EventType

Event::id

source

fn Event::id(self : Event) -> GamepadId

Event::is_dropped

source

fn Event::is_dropped(self : Event) -> Bool

Event::new

source

fn Event::new(id : GamepadId, event : EventType) -> Event

Event::time

source

fn Event::time(self : Event) -> Int64

EventType

source

pub(all) enum EventType {
  ButtonPressed(Button, Int)
  ButtonRepeated(Button, Int)
  ButtonReleased(Button, Int)
  ButtonChanged(Button, Double, Int)
  AxisChanged(Axis, Double, Int)
  Connected
  Disconnected
  Dropped
  ForceFeedbackEffectCompleted
}

FfEffectSource

source

type FfEffectSource

FfRepeat

source

pub enum FfRepeat {
  Infinitely
  For(Int64)
}

Gamepad

source

pub struct Gamepad {
  gil : Gil
  id : GamepadId
}

Gamepad::axes

source

fn Gamepad::axes(self : Gamepad) -> Array[Int]

Gamepad::axis_code

source

fn Gamepad::axis_code(self : Gamepad, axis : Axis) -> Int?

Gamepad::axis_data

source

fn Gamepad::axis_data(self : Gamepad, axis : Axis) -> AxisData?

Gamepad::axis_info

source

fn Gamepad::axis_info(self : Gamepad, code : Int) -> AxisInfo?

Gamepad::axis_or_btn_name

source

fn Gamepad::axis_or_btn_name(self : Gamepad, code : Int) -> AxisOrBtn?

Gamepad::button_code

source

fn Gamepad::button_code(self : Gamepad, btn : Button) -> Int?

Gamepad::button_data

source

fn Gamepad::button_data(self : Gamepad, btn : Button) -> ButtonData?

Gamepad::buttons

source

fn Gamepad::buttons(self : Gamepad) -> Array[Int]

Gamepad::deadzone

source

fn Gamepad::deadzone(self : Gamepad, code : Int) -> Double?

Gamepad::id

source

fn Gamepad::id(self : Gamepad) -> GamepadId

Gamepad::is_connected

source

fn Gamepad::is_connected(self : Gamepad) -> Bool

Gamepad::is_ff_supported

source

fn Gamepad::is_ff_supported(self : Gamepad) -> Bool

Gamepad::is_pressed

source

fn Gamepad::is_pressed(self : Gamepad, btn : Button) -> Bool

Gamepad::map_name

source

fn Gamepad::map_name(self : Gamepad) -> String?

Gamepad::mapping

source

fn Gamepad::mapping(self : Gamepad) -> Mapping?

Gamepad::mapping_source

source

fn Gamepad::mapping_source(self : Gamepad) -> MappingSource

Gamepad::name

source

fn Gamepad::name(self : Gamepad) -> String

Gamepad::os_name

source

fn Gamepad::os_name(self : Gamepad) -> String

Gamepad::power_info

source

fn Gamepad::power_info(self : Gamepad) -> PowerInfo

Gamepad::product_id

source

fn Gamepad::product_id(self : Gamepad) -> Int?

Gamepad::set_listener_position

source

fn Gamepad::set_listener_position(self : Gamepad, position : (Double, Double, Double)) -> Unit raise FfError

Gamepad::state

source

fn Gamepad::state(self : Gamepad) -> GamepadState

Gamepad::uuid

source

fn Gamepad::uuid(self : Gamepad) -> Uuid

Gamepad::value

source

fn Gamepad::value(self : Gamepad, axis : Axis) -> Double

Gamepad::vendor_id

source

fn Gamepad::vendor_id(self : Gamepad) -> Int?

GamepadData

source

pub struct GamepadData {
  state : GamepadState
  connected : Bool
  mapping : Mapping
  name : String
  uuid : Uuid
  vendor_id : Int?
  product_id : Int?
  ff_supported : Bool
  listener_position : (Double, Double, Double)
  power_info : PowerInfo
  axes : Array[Int]
  buttons : Array[Int]
  axis_info : Array[(Int, AxisInfo)]
  deadzones : Array[(Int, Double)]
  have_sent_nonzero_for_axis : Array[Bool]
}

GamepadId

source

pub struct GamepadId {
  value : Int
}

GamepadId::GamepadId

source

fn GamepadId::GamepadId(value : Int) -> GamepadId

GamepadId::new

source

fn GamepadId::new(value : Int) -> GamepadId

GamepadId::value

source

fn GamepadId::value(self : GamepadId) -> Int

GamepadState

source

pub struct GamepadState {
  buttons : Array[(Int, ButtonData)]
  axes : Array[(Int, AxisData)]
}

GamepadState::axes_entries

source

fn GamepadState::axes_entries(self : GamepadState) -> Array[(Int, AxisData)]

GamepadState::axis_data

source

fn GamepadState::axis_data(self : GamepadState, axis : Int) -> AxisData?

GamepadState::button_data

source

fn GamepadState::button_data(self : GamepadState, btn : Int) -> ButtonData?

GamepadState::buttons_entries

source

fn GamepadState::buttons_entries(self : GamepadState) -> Array[(Int, ButtonData)]

GamepadState::is_pressed

source

fn GamepadState::is_pressed(self : GamepadState, btn : Int) -> Bool

GamepadState::new

source

fn GamepadState::new() -> GamepadState

GamepadState::value

source

fn GamepadState::value(self : GamepadState, el : Int) -> Double

Gil

source

pub struct Gil {
  counter : Int64
  update_state : Bool
  default_filters : Bool
  axis_to_btn_pressed : Double
  axis_to_btn_released : Double
  events : Array[Event]
  events_head : Int
  gamepads_data : Array[GamepadData]
  mappings : MappingDb
  now_ms : Int64
  next_effect_token : Int
  ff_tick_base_ms : Int64
  ff_tick : Int
  ff_dirty : Bool
  ff_effects : Array[FfEffectSource]
  ff_events : Array[Event]
  ff_events_head : Int
  backend : NativeBackend?
}

Gil::axis_code

source

fn Gil::axis_code(self : Gil, id : GamepadId, axis : Axis) -> Int?

Gil::axis_or_btn_name

source

fn Gil::axis_or_btn_name(self : Gil, id : GamepadId, code : Int) -> AxisOrBtn?

Gil::button_code

source

fn Gil::button_code(self : Gil, id : GamepadId, btn : Button) -> Int?

Gil::connected_gamepad

source

fn Gil::connected_gamepad(self : Gil, id : GamepadId) -> Gamepad?

Gil::counter

source

fn Gil::counter(self : Gil) -> Int64

Gil::deadzone

source

fn Gil::deadzone(self : Gil, id : GamepadId, code : Int) -> Double?

Gil::default_filters_enabled

source

fn Gil::default_filters_enabled(self : Gil) -> Bool

Gil::gamepad

source

fn Gil::gamepad(self : Gil, id : GamepadId) -> Gamepad?

Gil::gamepads

source

fn Gil::gamepads(self : Gil) -> Array[(GamepadId, Gamepad)]

Gil::inc

source

fn Gil::inc(self : Gil) -> Unit

Gil::insert_event

source

fn Gil::insert_event(self : Gil, ev : Event) -> Unit

Gil::is_connected

source

fn Gil::is_connected(self : Gil, id : GamepadId) -> Bool

Gil::load_mappings

source

fn Gil::load_mappings(self : Gil, s : String) -> Unit

Gil::mapping

source

fn Gil::mapping(self : Gil, id : GamepadId) -> Mapping?

Gil::new

source

fn Gil::new() -> Gil

Gil::new_mock

source

fn Gil::new_mock(gamepad_count : Int, update_state? : Bool, default_filters? : Bool) -> Gil

Gil::new_native

source

fn Gil::new_native(update_state? : Bool, default_filters? : Bool) -> Gil

Gil::next_event

source

fn Gil::next_event(self : Gil) -> Event?

Gil::next_event_blocking

source

fn Gil::next_event_blocking(self : Gil, timeout_ms : Int64?) -> Event?

Gil::poll

source

fn Gil::poll(self : Gil) -> Unit

Gil::reset_counter

source

fn Gil::reset_counter(self : Gil) -> Unit

Gil::set_axis_to_btn

source

fn Gil::set_axis_to_btn(self : Gil, pressed : Double, released : Double) -> Unit raise GilError

Gil::set_deadzone

source

fn Gil::set_deadzone(self : Gil, id : GamepadId, code : Int, threshold : Double) -> Unit

Gil::set_mapping

source

fn Gil::set_mapping(self : Gil, id : GamepadId, mapping : Mapping) -> Unit

Gil::set_mapping_data

source

fn Gil::set_mapping_data(self : Gil, id : GamepadId, mapping_data : MappingData, name? : String?) -> String raise MappingError

Gil::set_mapping_data_strict

source

fn Gil::set_mapping_data_strict(self : Gil, id : GamepadId, mapping_data : MappingData, name? : String?) -> String raise MappingError

Gil::set_time

source

fn Gil::set_time(self : Gil, now_ms : Int64) -> Unit

Gil::state

source

fn Gil::state(self : Gil, id : GamepadId) -> GamepadState?

Gil::time

source

fn Gil::time(self : Gil) -> Int64

Gil::update

source

fn Gil::update(self : Gil, event : Event) -> Unit

Gil::update_state_enabled

source

fn Gil::update_state_enabled(self : Gil) -> Bool

Gil::with_default_filters

source

fn Gil::with_default_filters(self : Gil, enabled : Bool) -> Gil

GilBuilder

source

pub struct GilBuilder {
  update_state : Bool
  default_filters : Bool
  axis_to_btn_pressed : Double
  axis_to_btn_released : Double
  env_mappings : Bool
  included_mappings : Bool
  mock_gamepad_count : Int
  use_native_backend : Bool
  mapping_inputs : Array[String]
}

GilBuilder::add_env_mappings

source

fn GilBuilder::add_env_mappings(self : GilBuilder, env_mappings : Bool) -> GilBuilder

GilBuilder::add_included_mappings

source

fn GilBuilder::add_included_mappings(self : GilBuilder, included_mappings : Bool) -> GilBuilder

GilBuilder::add_mappings

source

fn GilBuilder::add_mappings(self : GilBuilder, mappings : String) -> GilBuilder

GilBuilder::build

source

fn GilBuilder::build(self : GilBuilder) -> Gil raise GilError

GilBuilder::new

source

fn GilBuilder::new() -> GilBuilder

GilBuilder::set_axis_to_btn

source

fn GilBuilder::set_axis_to_btn(self : GilBuilder, pressed : Double, released : Double) -> GilBuilder

GilBuilder::set_update_state

source

fn GilBuilder::set_update_state(self : GilBuilder, v : Bool) -> GilBuilder

GilBuilder::with_default_filters

source

fn GilBuilder::with_default_filters(self : GilBuilder, v : Bool) -> GilBuilder

GilBuilder::with_mock_gamepad_count

source

fn GilBuilder::with_mock_gamepad_count(self : GilBuilder, n : Int) -> GilBuilder

GilBuilder::with_native_backend

source

fn GilBuilder::with_native_backend(self : GilBuilder, v : Bool) -> GilBuilder

Jitter

source

pub struct Jitter {
  threshold : Double
}

Jitter::filter

source

fn Jitter::filter(self : Jitter, ev : Event?, gil : Gil) -> Event?

Jitter::new

source

fn Jitter::new() -> Jitter

Mapping

source

pub struct Mapping {
  mappings : Array[(Int, AxisOrBtn)]
  name : String
  default : Bool
  hats_mapped : Int
}

Mapping::entries

source

fn Mapping::entries(self : Mapping) -> Array[(Int, AxisOrBtn)]

Mapping::from_data

source

fn Mapping::from_data(data : MappingData, buttons : Array[Int], axes : Array[Int], name : String, uuid : Uuid) -> (Mapping, String) raise MappingError

Mapping::hats_mapped

source

fn Mapping::hats_mapped(self : Mapping) -> Int

Mapping::insert

source

fn Mapping::insert(self : Mapping, code : Int, el : AxisOrBtn) -> Unit

Mapping::is_default

source

fn Mapping::is_default(self : Mapping) -> Bool

Mapping::map

source

fn Mapping::map(self : Mapping, code : Int) -> AxisOrBtn?

Mapping::map_rev

source

fn Mapping::map_rev(self : Mapping, el : AxisOrBtn) -> Int?

Mapping::name

source

fn Mapping::name(self : Mapping) -> String

Mapping::new

source

fn Mapping::new() -> Mapping

Mapping::new_default

source

fn Mapping::new_default() -> Mapping

Mapping::parse_sdl_mapping

source

fn Mapping::parse_sdl_mapping(line : String, buttons : Array[Int], axes : Array[Int]) -> Mapping raise ParseSdlMappingError

Mapping::set_hats_mapped

source

fn Mapping::set_hats_mapped(self : Mapping, hats : Int) -> Unit

MappingData

source

pub struct MappingData {
  buttons : Array[Int?]
  axes : Array[Int?]
}

MappingData::axis

source

fn MappingData::axis(self : MappingData, idx : Axis) -> Int?

MappingData::button

source

fn MappingData::button(self : MappingData, idx : Button) -> Int?

MappingData::insert_axis

source

fn MappingData::insert_axis(self : MappingData, from : Int, to : Axis) -> Int?

MappingData::insert_btn

source

fn MappingData::insert_btn(self : MappingData, from : Int, to : Button) -> Int?

MappingData::new

source

fn MappingData::new() -> MappingData

MappingData::remove_axis

source

fn MappingData::remove_axis(self : MappingData, idx : Axis) -> Int?

MappingData::remove_button

source

fn MappingData::remove_button(self : MappingData, idx : Button) -> Int?

MappingDb

source

pub struct MappingDb {
  mappings : Array[(Uuid, String)]
}

MappingDb::add_env_mappings

source

fn MappingDb::add_env_mappings(self : MappingDb) -> Unit

MappingDb::add_included_mappings

source

fn MappingDb::add_included_mappings(self : MappingDb) -> Unit

MappingDb::get

source

fn MappingDb::get(self : MappingDb, uuid : Uuid) -> String?

MappingDb::insert

source

fn MappingDb::insert(self : MappingDb, s : String) -> Unit

MappingDb::len

source

fn MappingDb::len(self : MappingDb) -> Int

MappingDb::new

source

fn MappingDb::new() -> MappingDb

MappingSource

source

pub enum MappingSource {
  SdlMappings
  Driver
  None
}

NativeBackend

source

pub struct NativeBackend {
  owner : BackendOwner
}

NativeBackend::axes

source

fn NativeBackend::axes(self : NativeBackend, id : Int) -> Array[Int]

NativeBackend::axis_info

source

fn NativeBackend::axis_info(self : NativeBackend, id : Int, code : Int) -> AxisInfo?

NativeBackend::buttons

source

fn NativeBackend::buttons(self : NativeBackend, id : Int) -> Array[Int]

NativeBackend::gamepad_count

source

fn NativeBackend::gamepad_count(self : NativeBackend) -> Int

NativeBackend::is_connected

source

fn NativeBackend::is_connected(self : NativeBackend, id : Int) -> Bool

NativeBackend::is_ff_supported

source

fn NativeBackend::is_ff_supported(self : NativeBackend, id : Int) -> Bool

NativeBackend::last_gamepad_hint

source

fn NativeBackend::last_gamepad_hint(self : NativeBackend) -> Int

NativeBackend::name

source

fn NativeBackend::name(self : NativeBackend, id : Int) -> String

NativeBackend::new

source

fn NativeBackend::new() -> NativeBackend

NativeBackend::next_event

source

fn NativeBackend::next_event(self : NativeBackend) -> NativeEvent?

NativeBackend::poll

source

fn NativeBackend::poll(self : NativeBackend) -> Unit

NativeBackend::poll_timeout

source

fn NativeBackend::poll_timeout(self : NativeBackend, timeout_ms : Int) -> Unit

NativeBackend::power_info

source

fn NativeBackend::power_info(self : NativeBackend, id : Int) -> PowerInfo

NativeBackend::product_id

source

fn NativeBackend::product_id(self : NativeBackend, id : Int) -> Int?

NativeBackend::set_rumble

source

fn NativeBackend::set_rumble(self : NativeBackend, id : Int, strong : Double, weak : Double, duration_ms : Int) -> Bool

NativeBackend::uuid_simple

source

fn NativeBackend::uuid_simple(self : NativeBackend, id : Int) -> String

NativeBackend::vendor_id

source

fn NativeBackend::vendor_id(self : NativeBackend, id : Int) -> Int?

NativeEvent

source

pub struct NativeEvent {
  tag : NativeEventTag
  id : Int
  code : Int
  value : Double
  time_ms : Int64
}

NativeEventTag

source

pub(all) enum NativeEventTag {
  Connected
  Disconnected
  ButtonPressed
  ButtonReleased
  AxisChanged
  ButtonChanged
}

ParserErrorKind

source

pub(all) enum ParserErrorKind {
  InvalidGuid
  InvalidKeyValPair
  InvalidValue
  EmptyValue
  UnknownAxis
  UnknownButton
  InvalidParserState
  UnexpectedEnd
}

PowerInfo

source

pub enum PowerInfo {
  Unknown
  Wired
  Discharging(Int)
  Charging(Int)
  Charged
}

Repeat

source

pub struct Repeat {
  after_ms : Int64
  every_ms : Int64
}

Repeat::filter

source

fn Repeat::filter(self : Repeat, ev : Event?, gil : Gil) -> Event?

Repeat::new

source

fn Repeat::new() -> Repeat

Replay

source

pub struct Replay {
  after : Int
  play_for : Int
  with_delay : Int
}

Replay::at

source

fn Replay::at(self : Replay, ticks : Int) -> Double

Replay::default

source

fn Replay::default() -> Replay

Replay::dur

source

fn Replay::dur(self : Replay) -> Int

Ticks

source

pub struct Ticks {
  ms : Int64
}

Ticks::as_ms

source

fn Ticks::as_ms(self : Ticks) -> Int64

Ticks::from_ms

source

fn Ticks::from_ms(ms : Int64) -> Ticks

Token

source

pub(all) enum Token {
  Uuid(Uuid)
  Platform(String)
  Name(String)
  AxisMapping(Int, AxisOrBtn, AxisRange, AxisRange, Bool)
  ButtonMapping(Int, AxisOrBtn, AxisRange)
  HatMapping(Int, Int, AxisOrBtn, AxisRange)
}

Uuid

source

pub struct Uuid {
  simple : String
}

Uuid::nil

source

fn Uuid::nil() -> Uuid

Uuid::parse

source

fn Uuid::parse(s : String) -> Uuid raise UuidError

Uuid::simple

source

fn Uuid::simple(self : Uuid) -> String

AXIS_COUNT

source

let AXIS_COUNT : Int

AXIS_DPADX

source

let AXIS_DPADX : Int

AXIS_DPADY

source

let AXIS_DPADY : Int

AXIS_LEFTZ

source

let AXIS_LEFTZ : Int

AXIS_LSTICKX

source

let AXIS_LSTICKX : Int

AXIS_LSTICKY

source

let AXIS_LSTICKY : Int

AXIS_LT

source

let AXIS_LT : Int

AXIS_LT2

source

let AXIS_LT2 : Int

AXIS_RIGHTZ

source

let AXIS_RIGHTZ : Int

AXIS_RSTICKX

source

let AXIS_RSTICKX : Int

AXIS_RSTICKY

source

let AXIS_RSTICKY : Int

AXIS_RT

source

let AXIS_RT : Int

AXIS_RT2

source

let AXIS_RT2 : Int

BTN_C

source

let BTN_C : Int

BTN_DPAD_DOWN

source

let BTN_DPAD_DOWN : Int

BTN_DPAD_LEFT

source

let BTN_DPAD_LEFT : Int

BTN_DPAD_RIGHT

source

let BTN_DPAD_RIGHT : Int

BTN_DPAD_UP

source

let BTN_DPAD_UP : Int

BTN_EAST

source

let BTN_EAST : Int

BTN_LT

source

let BTN_LT : Int

BTN_LT2

source

let BTN_LT2 : Int

BTN_LTHUMB

source

let BTN_LTHUMB : Int

BTN_MODE

source

let BTN_MODE : Int

BTN_NORTH

source

let BTN_NORTH : Int

BTN_RT

source

let BTN_RT : Int

BTN_RT2

source

let BTN_RT2 : Int

BTN_RTHUMB

source

let BTN_RTHUMB : Int

BTN_SELECT

source

let BTN_SELECT : Int

BTN_SOUTH

source

let BTN_SOUTH : Int

BTN_START

source

let BTN_START : Int

BTN_WEST

source

let BTN_WEST : Int

BTN_Z

source

let BTN_Z : Int

BUTTON_COUNT

source

let BUTTON_COUNT : Int

LEGACY_AXIS_DPADX

source

let LEGACY_AXIS_DPADX : Int

LEGACY_AXIS_DPADY

source

let LEGACY_AXIS_DPADY : Int

LEGACY_AXIS_LEFTZ

source

let LEGACY_AXIS_LEFTZ : Int

LEGACY_AXIS_LSTICKX

source

let LEGACY_AXIS_LSTICKX : Int

LEGACY_AXIS_LSTICKY

source

let LEGACY_AXIS_LSTICKY : Int

LEGACY_AXIS_LT

source

let LEGACY_AXIS_LT : Int

LEGACY_AXIS_LT2

source

let LEGACY_AXIS_LT2 : Int

LEGACY_AXIS_RIGHTZ

source

let LEGACY_AXIS_RIGHTZ : Int

LEGACY_AXIS_RSTICKX

source

let LEGACY_AXIS_RSTICKX : Int

LEGACY_AXIS_RSTICKY

source

let LEGACY_AXIS_RSTICKY : Int

LEGACY_AXIS_RT

source

let LEGACY_AXIS_RT : Int

LEGACY_AXIS_RT2

source

let LEGACY_AXIS_RT2 : Int

LEGACY_BTN_C

source

let LEGACY_BTN_C : Int

LEGACY_BTN_DPAD_DOWN

source

let LEGACY_BTN_DPAD_DOWN : Int

LEGACY_BTN_DPAD_LEFT

source

let LEGACY_BTN_DPAD_LEFT : Int

LEGACY_BTN_DPAD_RIGHT

source

let LEGACY_BTN_DPAD_RIGHT : Int

LEGACY_BTN_DPAD_UP

source

let LEGACY_BTN_DPAD_UP : Int

LEGACY_BTN_EAST

source

let LEGACY_BTN_EAST : Int

LEGACY_BTN_LT

source

let LEGACY_BTN_LT : Int

LEGACY_BTN_LT2

source

let LEGACY_BTN_LT2 : Int

LEGACY_BTN_LTHUMB

source

let LEGACY_BTN_LTHUMB : Int

LEGACY_BTN_MODE

source

let LEGACY_BTN_MODE : Int

LEGACY_BTN_NORTH

source

let LEGACY_BTN_NORTH : Int

LEGACY_BTN_RT

source

let LEGACY_BTN_RT : Int

LEGACY_BTN_RT2

source

let LEGACY_BTN_RT2 : Int

LEGACY_BTN_RTHUMB

source

let LEGACY_BTN_RTHUMB : Int

LEGACY_BTN_SELECT

source

let LEGACY_BTN_SELECT : Int

LEGACY_BTN_SOUTH

source

let LEGACY_BTN_SOUTH : Int

LEGACY_BTN_START

source

let LEGACY_BTN_START : Int

LEGACY_BTN_WEST

source

let LEGACY_BTN_WEST : Int

LEGACY_BTN_Z

source

let LEGACY_BTN_Z : Int

PAGE_BUTTON

source

let PAGE_BUTTON : Int

PAGE_GENERIC_DESKTOP

source

let PAGE_GENERIC_DESKTOP : Int

PAGE_SIMULATION

source

let PAGE_SIMULATION : Int

axis_dpad_to_button

source

fn axis_dpad_to_button(ev : Event?, gil : Gil) -> Event?

axis_from_code

source

fn axis_from_code(code : Int) -> Axis?

axis_or_btn_from_code

source

fn axis_or_btn_from_code(code : Int) -> AxisOrBtn?

axis_value

source

fn axis_value(info : AxisInfo, val : Int, axis : Axis) -> Double

btn_value

source

fn btn_value(info : AxisInfo, val : Int) -> Double

button_from_code

source

fn button_from_code(code : Int) -> Button?

ceil_div

source

fn ceil_div(a : UInt, b : UInt) -> UInt

clamp

source

fn clamp(x : Double, min : Double, max : Double) -> Double

deadzone

source

fn deadzone(ev : Event?, gil : Gil) -> Event?

decode_native_event

source

fn decode_native_event(b : Bytes) -> NativeEvent?

default_axis_code

source

fn default_axis_code(axis : Axis) -> Int?

default_button_code

source

fn default_button_code(btn : Button) -> Int?

filter_ev

source

fn filter_ev(ev : Event?, filter : (Event?, Gil) -> Event?, gil : Gil) -> Event?

hid_code

source

fn hid_code(page : Int, usage : Int) -> Int

hid_page

source

fn hid_page(code : Int) -> Int

hid_usage

source

fn hid_usage(code : Int) -> Int

jitter

source

fn jitter(ev : Event?, gil : Gil, threshold : Double) -> Event?

runtime_env_sdl_gamecontrollerconfig

source

fn runtime_env_sdl_gamecontrollerconfig() -> String

runtime_now_ms

source

fn runtime_now_ms() -> Int64

runtime_sdl_platform_name

source

fn runtime_sdl_platform_name() -> String

Source Files

Site source Report issue Packages Build queue Skills Statistics

gamepad

#Milky2018/gamepad

#Install

#Platform Support

#Features

#API Notes

#Force Feedback

#Quick Start

#Mock Example

#Notes

#License

#Code

#DistanceModelError

#FfError

#GilError

#GilError::is_invalid_axis_to_btn

#MappingError

#MappingError::invalid_code

#ParseSdlMappingError

#ParserError

#ParserError::kind

#ParserError::position

#UuidError

#Axis

#Axis::is_stick

#Axis::second_axis

#Axis::to_index

#AxisData

#AxisData::counter

#AxisData::timestamp

#AxisData::value

#AxisInfo

#AxisInfo::new

#AxisOrBtn

#AxisOrBtn::is_button

#AxisRange

#BackendOwner

#BaseEffect

#BaseEffect::default

#BaseEffectType

#Button

#Button::is_action

#Button::is_dpad

#Button::is_menu

#Button::is_stick

#Button::is_trigger

#Button::to_index

#ButtonData

#ButtonData::counter

#ButtonData::is_pressed

#ButtonData::is_repeating

#ButtonData::timestamp

#ButtonData::value

#DistanceModel

#DistanceModel::validate

#Effect

#Effect::add_gamepad

#Effect::play

#Effect::set_distance_model

#Effect::set_gain

#Effect::set_gamepads

#Effect::set_position

#Effect::set_repeat

#Effect::stop

#EffectBuilder

#EffectBuilder::add_effect

#EffectBuilder::add_gamepad

#EffectBuilder::add_gamepad_id

#EffectBuilder::distance_model

#EffectBuilder::duration

#EffectBuilder::finish

#EffectBuilder::gain

#EffectBuilder::gamepads

#EffectBuilder::new

#EffectBuilder::position

#EffectBuilder::repeat

#EffectBuilder::rumble

#Envelope

#Envelope::at

#Envelope::default

Code

DistanceModelError

FfError

GilError

GilError::is_invalid_axis_to_btn

MappingError

MappingError::invalid_code

ParseSdlMappingError

ParserError

ParserError::kind

ParserError::position

UuidError

Axis

Axis::is_stick

Axis::second_axis

Axis::to_index

AxisData

AxisData::counter

AxisData::timestamp

AxisData::value

AxisInfo

AxisInfo::new

AxisOrBtn

AxisOrBtn::is_button

AxisRange

BackendOwner

BaseEffect

BaseEffect::default

BaseEffectType

Button

Button::is_action

Button::is_dpad

Button::is_menu

Button::is_stick

Button::is_trigger

Button::to_index

ButtonData

ButtonData::counter

ButtonData::is_pressed

ButtonData::is_repeating

ButtonData::timestamp

ButtonData::value

DistanceModel

DistanceModel::validate

Effect

Effect::add_gamepad

Effect::play

Effect::set_distance_model

Effect::set_gain

Effect::set_gamepads

Effect::set_position

Effect::set_repeat

Effect::stop

EffectBuilder

EffectBuilder::add_effect

EffectBuilder::add_gamepad

EffectBuilder::add_gamepad_id

EffectBuilder::distance_model

EffectBuilder::duration

EffectBuilder::finish

EffectBuilder::gain

EffectBuilder::gamepads

EffectBuilder::new

EffectBuilder::position

EffectBuilder::repeat

EffectBuilder::rumble

Envelope

Envelope::at

Envelope::default

Event

Event::at

Event::drop

Event::event

Event::id

Event::is_dropped

Event::new

Event::time

EventType

FfEffectSource

FfRepeat