Struct amethyst_input::Bindings

pub struct Bindings<T: BindingTypes> { /* fields omitted */ }

Used for saving and loading input settings.

An action can either be a single button or a combination of them.

Examples

Example Ron config file:

(
    axes: {
        "updown": Emulated(
            pos: Key(Up),
            neg: Key(Down)
        ),
        "leftright": Emulated(
            pos: Key(Right),
            neg: Key(Left)
        )
    },
    actions: {
        "fire": [ [Mouse(Left)], [Key(X)] ], // Multiple bindings for one action
        "reload": [ [Key(LControl), Key(R)] ] // Combinations of multiple bindings possible
    }
)

Methods

impl<T: BindingTypes> Bindings<T>

pub fn new() -> Self

Creates a new empty Bindings structure

impl<T: BindingTypes> Bindings<T>

pub fn insert_axis<A: Into<T::Axis>>(
    &mut self,
    id: A,
    axis: Axis
) -> Result<Option<Axis>, BindingError<T>>

Assign an axis to an ID value

This will insert a new axis if no entry for this id exists. If one does exist this will replace the axis at that id and return it.

pub fn remove_axis<A: ?Sized>(&mut self, id: &A) -> Option<Axis> where
    T::Axis: Borrow<A>,
    A: Hash + Eq, 

Removes an axis, this will return the removed axis if successful.

pub fn axis<A: ?Sized>(&self, id: &A) -> Option<&Axis> where
    T::Axis: Borrow<A>,
    A: Hash + Eq, 

Returns a reference to an axis.

pub fn axes(&self) -> impl Iterator<Item = &T::Axis>

Gets a list of all axes

pub fn insert_action_binding<B: IntoIterator<Item = Button>>(
    &mut self,
    id: T::Action,
    binding: B
) -> Result<(), BindingError<T>>

Add a button or button combination to an action.

This will attempt to insert a new binding between this action and the button(s).

pub fn remove_action_binding<A: ?Sized>(
    &mut self,
    id: &A,
    binding: &[Button]
) -> Result<(), ActionRemovedError> where
    T::Action: Borrow<A>,
    A: Hash + Eq, 

Removes an action binding that was assigned previously.

pub fn action_bindings<A: ?Sized>(
    &self,
    id: &A
) -> impl Iterator<Item = &[Button]> where
    T::Action: Borrow<A>,
    A: Hash + Eq, 

Returns an action's bindings.

pub fn actions(&self) -> impl Iterator<Item = &T::Action>

Gets a list of all action bindings

pub fn check_invariants(&mut self) -> Result<(), BindingError<T>>

Check that this structure upholds its guarantees. Should only be necessary when serializing or deserializing the bindings.

Trait Implementations

impl<T: BindingTypes> Default for Bindings<T>

fn default() -> Self

Returns the "default value" for a type.

impl<T: BindingTypes> Clone for Bindings<T>

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: BindingTypes> Debug for Bindings<T>

fn fmt(&self, __f: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<'de, T: BindingTypes> Deserialize<'de> for Bindings<T> where
    T::Axis: Deserialize<'de>,
    T::Action: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.

impl<T: BindingTypes> Serialize for Bindings<T> where
    T::Axis: Serialize,
    T::Action: Serialize, 

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error> where
    __S: Serializer, 

Serialize this value into the given Serde serializer.