lib_g29/
events.rs

1use rayon::prelude::*;
2use std::{collections::HashMap, sync::RwLock, thread};
3
4use crate::{state, DpadPosition, Frame, G29};
5
6pub type HandlerFn = fn(g29: &mut G29);
7
8#[derive(Debug, PartialEq, Copy, Clone, Eq, Hash)]
9pub enum Event {
10    /// Steering wheel is turned
11    Steering,
12    /// Steering wheel is turned finely
13    SteeringFine,
14    /// Throttle changed
15    Throttle,
16    /// Brake changed
17    Brake,
18    /// Clutch changed
19    Clutch,
20    DpadUpPressed,
21    DpadUpReleased,
22    DpadTopRightPressed,
23    DpadTopRightReleased,
24    DpadRightPressed,
25    DpadRightReleased,
26    DpadBottomRightPressed,
27    DpadBottomRightReleased,
28    DpadBottomPressed,
29    DpadBottomReleased,
30    DpadBottomLeftPressed,
31    DpadBottomLeftReleased,
32    DpadLeftPressed,
33    DpadLeftReleased,
34    DpadTopLeftPressed,
35    DpadTopLeftReleased,
36    XButtonPressed,
37    XButtonReleased,
38    SquareButtonPressed,
39    SquareButtonReleased,
40    CircleButtonPressed,
41    CircleButtonReleased,
42    TriangleButtonPressed,
43    TriangleButtonReleased,
44    RightShifterPressed,
45    RightShifterReleased,
46    LeftShifterPressed,
47    LeftShifterReleased,
48    R2ButtonPressed,
49    R2ButtonReleased,
50    L2ButtonPressed,
51    L2ButtonReleased,
52    ShareButtonPressed,
53    ShareButtonReleased,
54    OptionsButtonPressed,
55    OptionsButtonReleased,
56    R3ButtonPressed,
57    R3ButtonReleased,
58    L3ButtonPressed,
59    L3ButtonReleased,
60    PlusButtonPressed,
61    PlusButtonReleased,
62    MinusButtonPressed,
63    MinusButtonReleased,
64    // Spinner is rotating right
65    SpinnerRight,
66    // Spinner is rotating left
67    SpinnerLeft,
68    SpinnerButtonPressed,
69    SpinnerButtonReleased,
70    PlaystationButtonPressed,
71    PlaystationButtonReleased,
72    /// Shifter X axis changed
73    ShifterX,
74    /// Shifter Y axis changed
75    ShifterY,
76    ShifterPressed,
77    ShifterReleased,
78    /// Gear selector changed
79    GearChanged,
80}
81
82#[derive(Debug, Copy, Clone)]
83pub struct EventHandler {
84    pub id: usize,
85    pub event: Event,
86    pub handler: HandlerFn,
87}
88
89#[derive(Debug)]
90pub struct EventHandlers {
91    pub event: Event,
92    pub next_id: usize,
93    pub handlers: HashMap<usize, EventHandler>,
94}
95
96impl EventHandlers {
97    pub fn new(event: Event) -> EventHandlers {
98        EventHandlers {
99            event,
100            next_id: 0,
101            handlers: HashMap::new(),
102        }
103    }
104
105    pub fn insert(&mut self, handler: HandlerFn) -> Option<EventHandler> {
106        let id = self.next_id;
107        self.next_id += 1;
108
109        let event_handler = EventHandler {
110            id,
111            event: self.event,
112            handler,
113        };
114
115        self.handlers.insert(id, event_handler);
116
117        Some(event_handler)
118    }
119}
120
121#[derive(Debug)]
122pub struct EventMap {
123    handlers: HashMap<Event, RwLock<EventHandlers>>,
124}
125
126impl Default for EventMap {
127    fn default() -> Self {
128        Self::new()
129    }
130}
131
132impl EventMap {
133    pub fn new() -> EventMap {
134        EventMap {
135            handlers: HashMap::new(),
136        }
137    }
138
139    pub fn insert(&mut self, event: Event, handler: HandlerFn) -> Option<EventHandler> {
140        self.handlers
141            .entry(event)
142            .or_insert_with(|| RwLock::new(EventHandlers::new(event)))
143            .write()
144            .unwrap()
145            .insert(handler)
146    }
147
148    pub fn remove(&mut self, event_handler: EventHandler) {
149        self.handlers
150            .get_mut(&event_handler.event)
151            .unwrap()
152            .write()
153            .unwrap()
154            .handlers
155            .remove(&event_handler.id);
156    }
157
158    fn trigger(&self, event: Event, g29: &mut G29) {
159        if let Some(handlers) = self.handlers.get(&event) {
160            let handlers = &handlers.read().unwrap().handlers;
161            handlers.par_iter().for_each(|(_, handler)| {
162                let mut self_1 = g29.clone();
163                let ev_clone = *handler; // Clone the event handler
164                thread::spawn(move || {
165                    (ev_clone.handler)(&mut self_1);
166                });
167            });
168        }
169    }
170
171    pub fn trigger_events(&self, prev_data: &Frame, new_data: &Frame, g29: &mut G29) {
172        let different_indices = different_indices(prev_data, new_data);
173
174        if different_indices.is_empty() {
175            return;
176        }
177
178        different_indices.par_iter().for_each(|index| {
179            let mut g29 = g29.clone();
180            match index {
181                0 => {
182                    self.trigger_dpad_events(prev_data, new_data, &mut g29);
183                    self.trigger_shape_button_events(prev_data, new_data, &mut g29);
184                }
185                1 => self.trigger_data1_button_events(prev_data, new_data, &mut g29),
186                2 => {
187                    self.trigger_gear_selector_events(prev_data, new_data, &mut g29);
188                    self.trigger_plus_button_events(prev_data, new_data, &mut g29);
189                }
190                3 => self.trigger_data3_button_events(prev_data, new_data, &mut g29),
191                4 | 5 => self.trigger_steering_events(prev_data, new_data, &mut g29),
192                6 => self.trigger_throttle_event(prev_data, new_data, &mut g29),
193                7 => self.trigger_brake_event(prev_data, new_data, &mut g29),
194                8 => self.trigger_clutch_event(prev_data, new_data, &mut g29),
195                9 => self.trigger_shifter_x_event(prev_data, new_data, &mut g29),
196                10 => self.trigger_shifter_y_event(prev_data, new_data, &mut g29),
197                11 => self.trigger_shifter_events(prev_data, new_data, &mut g29),
198                _ => {}
199            };
200        });
201    }
202
203    fn trigger_dpad_events(&self, prev_data: &Frame, new_data: &Frame, g29: &mut G29) {
204        let prev_dpad = state::dpad(prev_data);
205        let new_dpad = state::dpad(new_data);
206        if prev_dpad == new_dpad {
207            return;
208        }
209
210        // which dpad is pressed
211        match new_dpad {
212            DpadPosition::Up => self.trigger(Event::DpadUpPressed, g29),
213            DpadPosition::TopRight => self.trigger(Event::DpadTopRightPressed, g29),
214            DpadPosition::Right => self.trigger(Event::DpadRightPressed, g29),
215            DpadPosition::BottomRight => self.trigger(Event::DpadBottomRightPressed, g29),
216            DpadPosition::Down => self.trigger(Event::DpadBottomPressed, g29),
217            DpadPosition::BottomLeft => self.trigger(Event::DpadBottomLeftPressed, g29),
218            DpadPosition::Left => self.trigger(Event::DpadLeftPressed, g29),
219            DpadPosition::TopLeft => self.trigger(Event::DpadTopLeftPressed, g29),
220            _ => {}
221        };
222
223        // which dpad is released
224        match prev_dpad {
225            DpadPosition::Up => self.trigger(Event::DpadUpReleased, g29),
226            DpadPosition::TopRight => self.trigger(Event::DpadTopRightReleased, g29),
227            DpadPosition::Right => self.trigger(Event::DpadRightReleased, g29),
228            DpadPosition::BottomRight => self.trigger(Event::DpadBottomRightReleased, g29),
229            DpadPosition::Down => self.trigger(Event::DpadBottomReleased, g29),
230            DpadPosition::BottomLeft => self.trigger(Event::DpadBottomLeftReleased, g29),
231            DpadPosition::Left => self.trigger(Event::DpadLeftReleased, g29),
232            DpadPosition::TopLeft => self.trigger(Event::DpadTopLeftReleased, g29),
233            _ => {}
234        };
235    }
236
237    fn trigger_shape_button_events(&self, prev_data: &Frame, new_data: &Frame, g29: &mut G29) {
238        [
239            (Event::XButtonPressed, Event::XButtonReleased),
240            (Event::SquareButtonPressed, Event::SquareButtonReleased),
241            (Event::CircleButtonPressed, Event::CircleButtonReleased),
242            (Event::TriangleButtonPressed, Event::TriangleButtonReleased),
243        ]
244        .par_iter()
245        .for_each_with(g29.clone(), |g, (pressed, released)| {
246            let prev = match pressed {
247                Event::XButtonPressed => state::x_button(prev_data),
248                Event::SquareButtonPressed => state::square_button(prev_data),
249                Event::CircleButtonPressed => state::circle_button(prev_data),
250                Event::TriangleButtonPressed => state::triangle_button(prev_data),
251                _ => false,
252            };
253
254            let new = match pressed {
255                Event::XButtonPressed => state::x_button(new_data),
256                Event::SquareButtonPressed => state::square_button(new_data),
257                Event::CircleButtonPressed => state::circle_button(new_data),
258                Event::TriangleButtonPressed => state::triangle_button(new_data),
259                _ => false,
260            };
261
262            if prev != new {
263                if new {
264                    self.trigger(*pressed, g);
265                } else {
266                    self.trigger(*released, g);
267                }
268            }
269        });
270    }
271
272    fn trigger_data1_button_events(&self, prev_data: &Frame, new_data: &Frame, g29: &mut G29) {
273        [
274            (Event::RightShifterPressed, Event::RightShifterReleased),
275            (Event::LeftShifterPressed, Event::LeftShifterReleased),
276            (Event::R2ButtonPressed, Event::R2ButtonReleased),
277            (Event::L2ButtonPressed, Event::L2ButtonReleased),
278            (Event::ShareButtonPressed, Event::ShareButtonReleased),
279            (Event::OptionsButtonPressed, Event::OptionsButtonReleased),
280            (Event::R3ButtonPressed, Event::R3ButtonReleased),
281            (Event::L3ButtonPressed, Event::L3ButtonReleased),
282        ]
283        .par_iter()
284        .for_each_with(g29.clone(), |g, (pressed, released)| {
285            let prev = match pressed {
286                Event::RightShifterPressed => state::right_shifter(prev_data),
287                Event::LeftShifterPressed => state::left_shifter(prev_data),
288                Event::R2ButtonPressed => state::r2_button(prev_data),
289                Event::L2ButtonPressed => state::l2_button(prev_data),
290                Event::ShareButtonPressed => state::share_button(prev_data),
291                Event::OptionsButtonPressed => state::options_button(prev_data),
292                Event::R3ButtonPressed => state::r3_button(prev_data),
293                Event::L3ButtonPressed => state::l3_button(prev_data),
294                _ => false,
295            };
296
297            let new = match pressed {
298                Event::RightShifterPressed => state::right_shifter(new_data),
299                Event::LeftShifterPressed => state::left_shifter(new_data),
300                Event::R2ButtonPressed => state::r2_button(new_data),
301                Event::L2ButtonPressed => state::l2_button(new_data),
302                Event::ShareButtonPressed => state::share_button(new_data),
303                Event::OptionsButtonPressed => state::options_button(new_data),
304                Event::R3ButtonPressed => state::r3_button(new_data),
305                Event::L3ButtonPressed => state::l3_button(new_data),
306                _ => false,
307            };
308
309            if prev != new {
310                if new {
311                    self.trigger(*pressed, g);
312                } else {
313                    self.trigger(*released, g);
314                }
315            }
316        });
317    }
318
319    fn trigger_gear_selector_events(&self, prev_data: &Frame, new_data: &Frame, g29: &mut G29) {
320        let prev_gear_selector = state::gear_selector(prev_data);
321        let new_gear_selector = state::gear_selector(new_data);
322
323        if prev_gear_selector == new_gear_selector {
324            return;
325        }
326
327        self.trigger(Event::GearChanged, g29);
328    }
329
330    fn trigger_plus_button_events(&self, prev_data: &Frame, new_data: &Frame, g29: &mut G29) {
331        let prev_plus_button = state::plus_button(prev_data);
332        let new_plus_button = state::plus_button(new_data);
333        if prev_plus_button == new_plus_button {
334        } else if new_plus_button {
335            self.trigger(Event::PlusButtonPressed, g29);
336        } else {
337            self.trigger(Event::PlusButtonReleased, g29);
338        }
339    }
340
341    fn trigger_data3_button_events(&self, prev_data: &Frame, new_data: &Frame, g29: &mut G29) {
342        /*
343           minus_button
344           spinner_right
345           spinner_left
346           spinner_button
347           playstation_button
348        */
349        [
350            (Event::MinusButtonPressed, Event::MinusButtonReleased),
351            (Event::SpinnerRight, Event::SpinnerRight),
352            (Event::SpinnerLeft, Event::SpinnerLeft),
353            (Event::SpinnerButtonPressed, Event::SpinnerButtonReleased),
354            (
355                Event::PlaystationButtonPressed,
356                Event::PlaystationButtonReleased,
357            ),
358        ]
359        .par_iter()
360        .for_each_with(g29.clone(), |g, (pressed, released)| {
361            match pressed {
362                Event::SpinnerRight => {
363                    let prev_spinner_right = state::spinner_right(prev_data);
364                    let new_spinner_right = state::spinner_right(new_data);
365                    if prev_spinner_right != new_spinner_right && new_spinner_right {
366                        self.trigger(Event::SpinnerRight, g);
367                    }
368                    return;
369                }
370                Event::SpinnerLeft => {
371                    let prev_spinner_left = state::spinner_left(prev_data);
372                    let new_spinner_left = state::spinner_left(new_data);
373                    if prev_spinner_left != new_spinner_left && new_spinner_left {
374                        self.trigger(Event::SpinnerLeft, g);
375                    }
376                    return;
377                }
378                _ => {}
379            }
380
381            let prev = match pressed {
382                Event::MinusButtonPressed => state::minus_button(prev_data),
383                Event::SpinnerButtonPressed => state::spinner_button(prev_data),
384                Event::PlaystationButtonPressed => state::playstation_button(prev_data),
385                _ => false,
386            };
387
388            let new = match pressed {
389                Event::MinusButtonPressed => state::minus_button(new_data),
390                Event::SpinnerButtonPressed => state::spinner_button(new_data),
391                Event::PlaystationButtonPressed => state::playstation_button(new_data),
392                _ => false,
393            };
394
395            if prev != new {
396                if new {
397                    self.trigger(*pressed, g);
398                } else {
399                    self.trigger(*released, g);
400                }
401            }
402        });
403    }
404
405    fn trigger_steering_events(&self, prev_data: &Frame, new_data: &Frame, g29: &mut G29) {
406        [Event::Steering, Event::SteeringFine]
407            .par_iter()
408            .for_each_with(g29.clone(), |g29, op| {
409                let changed = match op {
410                    Event::Steering => state::steering(prev_data) != state::steering(new_data),
411                    Event::SteeringFine => {
412                        state::steering_fine(prev_data) != state::steering_fine(new_data)
413                    }
414                    _ => false,
415                };
416
417                if changed {
418                    self.trigger(*op, g29);
419                }
420            });
421    }
422
423    fn trigger_throttle_event(&self, prev_data: &Frame, new_data: &Frame, g29: &mut G29) {
424        let prev_throttle = state::throttle(prev_data);
425        let new_throttle = state::throttle(new_data);
426
427        if prev_throttle != new_throttle {
428            self.trigger(Event::Throttle, g29);
429        }
430    }
431
432    fn trigger_brake_event(&self, prev_data: &Frame, new_data: &Frame, g29: &mut G29) {
433        let prev_brake = state::brake(prev_data);
434        let new_brake = state::brake(new_data);
435
436        if prev_brake != new_brake {
437            self.trigger(Event::Brake, g29);
438        }
439    }
440
441    fn trigger_clutch_event(&self, prev_data: &Frame, new_data: &Frame, g29: &mut G29) {
442        let prev_clutch = state::clutch(prev_data);
443        let new_clutch = state::clutch(new_data);
444
445        if prev_clutch != new_clutch {
446            self.trigger(Event::Clutch, g29);
447        }
448    }
449
450    fn trigger_shifter_x_event(&self, prev_data: &Frame, new_data: &Frame, g29: &mut G29) {
451        let prev_shifter_x = state::shifter_x(prev_data);
452        let new_shifter_x = state::shifter_x(new_data);
453
454        if prev_shifter_x != new_shifter_x {
455            self.trigger(Event::ShifterX, g29);
456        }
457    }
458
459    fn trigger_shifter_y_event(&self, prev_data: &Frame, new_data: &Frame, g29: &mut G29) {
460        let prev_shifter_y = state::shifter_y(prev_data);
461        let new_shifter_y = state::shifter_y(new_data);
462
463        if prev_shifter_y != new_shifter_y {
464            self.trigger(Event::ShifterY, g29);
465        }
466    }
467
468    fn trigger_shifter_events(&self, prev_data: &Frame, new_data: &Frame, g29: &mut G29) {
469        let prev_shifter_pressed = state::shifter_pressed(prev_data);
470        let new_shifter_pressed = state::shifter_pressed(new_data);
471
472        if prev_shifter_pressed != new_shifter_pressed {
473            if new_shifter_pressed {
474                self.trigger(Event::ShifterPressed, g29);
475            } else {
476                self.trigger(Event::ShifterReleased, g29);
477            }
478        }
479    }
480}
481
482fn different_indices(data1: &Frame, data2: &Frame) -> Vec<usize> {
483    data1
484        .iter()
485        .enumerate()
486        .filter_map(|(i, &x)| if x != data2[i] { Some(i) } else { None })
487        .collect()
488}
489
490#[cfg(test)]
491mod tests {
492    use crate::Frame;
493
494    #[test]
495    fn test_different_indices_none() {
496        let data1: Frame = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
497        let data2: Frame = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
498
499        let result = crate::events::different_indices(&data1, &data2);
500        assert_eq!(result.len(), 0);
501    }
502
503    #[test]
504    fn test_different_indices_some() {
505        let data1: Frame = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12];
506        let data2: Frame = [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 13, 12];
507
508        let result = crate::events::different_indices(&data1, &data2);
509        assert_eq!(result.len(), 2);
510        assert_eq!(result, vec![9, 10]);
511    }
512}
lib_g29/events.rs

lib_g29/
events.rs
