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
124
125
126

use super::{DemuxMode, DemuxOutput, helpers};
use evdev::InputEvent;
use gilrs::{Button, Event, EventType, GamepadId, Gilrs};

/// Build-time flag to control latching behavior on active device switch.
const DEMUX_UNICAST_LATCHING: bool = false;

/// Unicast mode: Route primary to currently active virtual gamepad
/// Cycle active with Mode button
#[derive(Default)]
pub struct UnicastMode {
    active_index: usize,
}

impl UnicastMode {
    /// Synchronize controller state to newly active virtual device
    fn sync_controller_state(primary: gilrs::Gamepad) -> Vec<InputEvent> {
        let state = primary.state();
        let mut events = Vec::new();

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

            // Continue if button is Mode (exclusive binding)
            if 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, &primary, abs_axis));
            }
        }

        // Synchronize axis states
        for (code, axis_data) in state.axes() {
            let Some(gilrs::ev::AxisOrBtn::Axis(axis)) = primary.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, primary: 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, &primary, abs_axis)])
            }

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

            _ => None,
        }
    }
}

impl DemuxMode for UnicastMode {
    fn handle_event(
        &mut self,
        event: &Event,
        primary_id: GamepadId,
        virtuals: usize,
        gilrs: &Gilrs,
    ) -> Option<DemuxOutput> {
        if event.id != primary_id {
            return None;
        }

        // Handle mode button to cycle active device
        if matches!(event.event, EventType::ButtonPressed(Button::Mode, _)) {
            let old_active = self.active_index;
            self.active_index = (self.active_index + 1) % virtuals;

            let primary = gilrs.gamepad(primary_id);
            let sync_events = Self::sync_controller_state(primary);

            let mut events = Vec::new();

            // If latching is disabled, neutralize the previously active device
            if !DEMUX_UNICAST_LATCHING && old_active != self.active_index {
                let neutral_events = crate::utils::evdev::generate_neutral_gamepad_events();
                events.push((old_active, neutral_events));
            }

            events.push((self.active_index, sync_events));

            // Return events AND request to update active virtuals
            return Some(DemuxOutput {
                events,
                set_active_virtuals: Some(vec![self.active_index]),
            });
        }

        // Forward event to active device
        let primary = gilrs.gamepad(primary_id);
        Self::convert_event(event, primary)
            .map(|e| DemuxOutput::events(vec![(self.active_index, e)]))
    }

    fn initial_active_virtuals(&self, _virtuals: usize) -> Vec<usize> {
        // Unicast always starts at 0
        vec![0]
    }
}