ctrlassist 0.4.0

Controller Assist for gaming on Linux
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
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123

use super::{MuxMode, MuxOutput, helpers};
use evdev::InputEvent;
use gilrs::{Event, EventType, GamepadId, Gilrs};

#[derive(Default)]
pub struct ToggleMode {
    active_id: Option<GamepadId>,
}

impl ToggleMode {
    /// Synchronize all input states from the newly active controller
    fn sync_controller_state(
        active: gilrs::Gamepad,
        active_id: GamepadId,
        assist_id: GamepadId,
    ) -> Vec<InputEvent> {
        let state = active.state();
        let mut events = Vec::new();

        // Synchronize button states
        for (code, button_data) in state.buttons() {
            let Some(gilrs::ev::AxisOrBtn::Btn(btn)) = active.axis_or_btn_name(code) else {
                continue;
            };

            // Skip Mode button on assist controller for exclusive binding
            if active_id == assist_id && btn == gilrs::Button::Mode {
                continue;
            }

            // Handle buttons mapped to keys
            if let Some(event) = helpers::create_button_key_event(btn, button_data.is_pressed()) {
                events.push(event);
            }

            // Handle buttons mapped to axes (triggers, D-pad)
            if let Some(abs_axis) = crate::utils::evdev::gilrs_button_to_evdev_axis(btn) {
                events.push(helpers::process_button_axis(btn, &active, abs_axis));
            }
        }

        // Synchronize axis states
        for (code, axis_data) in state.axes() {
            let Some(gilrs::ev::AxisOrBtn::Axis(axis)) = active.axis_or_btn_name(code) else {
                continue;
            };

            if let Some(event) = helpers::create_stick_event(axis, axis_data.value()) {
                events.push(event);
            }
        }

        events
    }

    /// Convert a gilrs event to evdev events
    fn convert_event(event: &Event, active: gilrs::Gamepad) -> Option<Vec<InputEvent>> {
        match event.event {
            EventType::ButtonPressed(btn, _) | EventType::ButtonReleased(btn, _) => {
                let is_pressed = matches!(event.event, EventType::ButtonPressed(..));
                helpers::create_button_key_event(btn, is_pressed).map(|e| vec![e])
            }

            EventType::ButtonChanged(btn, _, _) => {
                let abs_axis = crate::utils::evdev::gilrs_button_to_evdev_axis(btn)?;
                Some(vec![helpers::process_button_axis(btn, &active, abs_axis)])
            }

            EventType::AxisChanged(axis, raw_val, _) => {
                helpers::create_stick_event(axis, raw_val).map(|e| vec![e])
            }

            _ => None,
        }
    }
}

impl MuxMode for ToggleMode {
    fn handle_event(
        &mut self,
        event: &Event,
        primary_id: GamepadId,
        assist_id: GamepadId,
        gilrs: &Gilrs,
    ) -> Option<MuxOutput> {
        let active_id = self.active_id.get_or_insert(primary_id);

        // Handle toggle logic
        if matches!(
            (event.id, event.event),
            (id, EventType::ButtonPressed(gilrs::Button::Mode, _)) if id == assist_id
        ) {
            *active_id = if *active_id == primary_id {
                assist_id
            } else {
                primary_id
            };

            let active = gilrs.gamepad(*active_id);
            let sync_events = Self::sync_controller_state(active, *active_id, assist_id);

            // Report the active controller change
            return Some(MuxOutput::with_active(sync_events, vec![*active_id]));
        }

        // Only forward events from the active controller
        if event.id != *active_id {
            return None;
        }

        let active = gilrs.gamepad(*active_id);
        Self::convert_event(event, active).map(MuxOutput::events)
    }

    /// Toggle always starts with primary active
    fn initial_active_controllers(
        &self,
        primary_id: GamepadId,
        _assist_id: GamepadId,
    ) -> Vec<GamepadId> {
        vec![primary_id]
    }
}