bevy_enhanced_input 0.23.0

Input manager for Bevy, inspired by Unreal Engine Enhanced Input
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

use crate::prelude::*;
use bevy::{
    ecs::spawn::SpawnableList,
    prelude::*,
    ptr::{MovingPtr, move_as_ptr},
};

/// A preset to map 6 buttons as 3-dimensional input.
#[derive(Debug, Clone, Copy)]
pub struct Spatial<F, B, L, R, U, D> {
    pub forward: F,
    pub backward: B,
    pub left: L,
    pub right: R,
    pub up: U,
    pub down: D,
}

impl<F, B, L, R, U, D, T: Clone> WithBundle<T> for Spatial<F, B, L, R, U, D> {
    type Output = Spatial<(F, T), (B, T), (L, T), (R, T), (U, T), (D, T)>;

    fn with(self, bundle: T) -> Self::Output {
        Spatial {
            forward: (self.forward, bundle.clone()),
            backward: (self.backward, bundle.clone()),
            left: (self.left, bundle.clone()),
            right: (self.right, bundle.clone()),
            up: (self.up, bundle.clone()),
            down: (self.down, bundle),
        }
    }
}

impl Spatial<Binding, Binding, Binding, Binding, Binding, Binding> {
    /// Maps 6 bindings as 3-dimensional input.
    #[must_use]
    pub fn new(
        forward: impl Into<Binding>,
        backward: impl Into<Binding>,
        left: impl Into<Binding>,
        right: impl Into<Binding>,
        up: impl Into<Binding>,
        down: impl Into<Binding>,
    ) -> Self {
        Spatial {
            forward: forward.into(),
            backward: backward.into(),
            left: left.into(),
            right: right.into(),
            up: up.into(),
            down: down.into(),
        }
    }

    /// Applies keyboard modifiers to all bindings.
    #[must_use]
    pub fn with_mod_keys(self, mod_keys: ModKeys) -> Self {
        Self {
            forward: self.forward.with_mod_keys(mod_keys),
            backward: self.backward.with_mod_keys(mod_keys),
            left: self.left.with_mod_keys(mod_keys),
            right: self.right.with_mod_keys(mod_keys),
            up: self.up.with_mod_keys(mod_keys),
            down: self.down.with_mod_keys(mod_keys),
        }
    }
}

impl<F, B, L, R, U, D> SpawnableList<BindingOf> for Spatial<F, B, L, R, U, D>
where
    F: Bundle,
    B: Bundle,
    L: Bundle,
    R: Bundle,
    U: Bundle,
    D: Bundle,
{
    fn spawn(this: MovingPtr<'_, Self>, world: &mut World, entity: Entity) {
        let spatial = this.read();
        let xy = Cardinal {
            north: spatial.up,
            east: spatial.right,
            south: spatial.down,
            west: spatial.left,
        };

        move_as_ptr!(xy);
        SpawnableList::spawn(xy, world, entity);

        let z = Bidirectional {
            positive: spatial.backward,
            negative: spatial.forward,
        }
        .with(SwizzleAxis::ZYX);

        move_as_ptr!(z);
        SpawnableList::spawn(z, world, entity);
    }

    fn size_hint(&self) -> usize {
        6
    }
}