use std::sync::atomic::{AtomicU8, Ordering};
pub(crate) const LEFT_BUTTON: u8 = 1 << 0;
pub(crate) const MIDDLE_BUTTON: u8 = 1 << 1;
pub(crate) const RIGHT_BUTTON: u8 = 1 << 2;
pub(crate) const BUTTON_MASK: u8 = 0b0000_0111;
#[derive(Debug)]
pub(crate) struct MouseStateDirtyMap {
bits: AtomicU8,
}
impl MouseStateDirtyMap {
pub(crate) const fn new() -> Self {
Self {
bits: AtomicU8::new(0),
}
}
pub(crate) fn merge(&self, mask: u8) {
let mask = mask & BUTTON_MASK;
if mask != 0 {
self.bits.fetch_or(mask, Ordering::SeqCst);
}
}
pub(crate) fn take(&self) -> u8 {
self.bits.swap(0, Ordering::SeqCst)
}
#[allow(unused)]
fn reset(&self) {
self.bits.store(0, Ordering::Relaxed);
}
}
impl Default for MouseStateDirtyMap {
fn default() -> Self {
Self::new()
}
}
#[derive(Debug)]
pub struct MouseState<'el> {
dirty_map: &'el MouseStateDirtyMap,
now: u8,
pre: u8,
}
impl<'el> MouseState<'el> {
pub(crate) const fn new(dirty_map: &'el MouseStateDirtyMap) -> Self {
Self {
dirty_map,
now: 0,
pre: 0,
}
}
pub fn update(&mut self) {
self.pre = self.now;
self.now = self.dirty_map.take();
}
pub fn is_left_pressed(&self) -> bool {
self.now & LEFT_BUTTON != 0
}
pub fn is_middle_pressed(&self) -> bool {
self.now & MIDDLE_BUTTON != 0
}
pub fn is_right_pressed(&self) -> bool {
self.now & RIGHT_BUTTON != 0
}
pub fn is_left_down(&self) -> bool {
(self.now & LEFT_BUTTON != 0) && (self.pre & LEFT_BUTTON == 0)
}
pub fn is_left_up(&self) -> bool {
(self.now & LEFT_BUTTON == 0) && (self.pre & LEFT_BUTTON != 0)
}
pub fn is_middle_down(&self) -> bool {
(self.now & MIDDLE_BUTTON != 0) && (self.pre & MIDDLE_BUTTON == 0)
}
pub fn is_middle_up(&self) -> bool {
(self.now & MIDDLE_BUTTON == 0) && (self.pre & MIDDLE_BUTTON != 0)
}
pub fn is_right_down(&self) -> bool {
(self.now & RIGHT_BUTTON != 0) && (self.pre & RIGHT_BUTTON == 0)
}
pub fn is_right_up(&self) -> bool {
(self.now & RIGHT_BUTTON == 0) && (self.pre & RIGHT_BUTTON != 0)
}
pub fn snapshot(&self) -> (u8, u8) {
(self.now, self.pre)
}
#[expect(dead_code, reason = "maybe use in the future")]
fn reset(&mut self) {
self.dirty_map.reset();
self.now = 0;
self.pre = 0;
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn dirty_map_merge_take_once() {
let map = MouseStateDirtyMap::new();
assert_eq!(map.take(), 0);
map.merge(LEFT_BUTTON);
map.merge(LEFT_BUTTON | RIGHT_BUTTON);
assert_eq!(map.take(), LEFT_BUTTON | RIGHT_BUTTON);
assert_eq!(map.take(), 0);
map.merge(0b1111_1111);
assert_eq!(map.take(), BUTTON_MASK);
}
#[test]
fn dirty_map_thread_safe() {
use std::sync::Arc;
let map = Arc::new(MouseStateDirtyMap::new());
let handles: Vec<_> = (0..8)
.map(|i| {
let bit = 1u8 << (i % 3);
let m = Arc::clone(&map);
std::thread::spawn(move || m.merge(bit))
})
.collect();
for h in handles {
h.join().unwrap();
}
assert_eq!(map.take(), BUTTON_MASK);
}
#[test]
fn edge_detection_sequence() {
let map = MouseStateDirtyMap::new();
let mut state = MouseState::new(&map);
state.update();
assert!(!state.is_left_down());
assert!(!state.is_left_up());
assert!(!state.is_left_pressed());
map.merge(LEFT_BUTTON);
state.update();
assert!(state.is_left_down());
assert!(state.is_left_pressed());
assert!(!state.is_left_up());
map.merge(LEFT_BUTTON);
state.update();
assert!(!state.is_left_down());
assert!(state.is_left_pressed());
state.update();
assert!(state.is_left_up());
assert!(!state.is_left_pressed());
assert!(!state.is_left_down());
}
#[test]
fn multiple_buttons_independent() {
let map = MouseStateDirtyMap::new();
let mut state = MouseState::new(&map);
state.update();
map.merge(LEFT_BUTTON | RIGHT_BUTTON);
state.update();
assert!(state.is_left_down());
assert!(state.is_right_down());
assert!(!state.is_middle_down());
assert!(state.is_left_pressed() && state.is_right_pressed());
map.merge(LEFT_BUTTON);
state.update();
assert!(state.is_right_up());
assert!(!state.is_right_pressed());
assert!(state.is_left_pressed());
map.merge(LEFT_BUTTON | MIDDLE_BUTTON);
state.update();
assert!(state.is_middle_down());
assert!(state.is_middle_pressed());
assert!(!state.is_middle_up());
assert!(state.is_left_pressed());
assert!(!state.is_left_down());
assert!(!state.is_right_pressed());
}
#[test]
fn snapshot_and_reset() {
let map = MouseStateDirtyMap::new();
let mut state = MouseState::new(&map);
state.update();
map.merge(LEFT_BUTTON | MIDDLE_BUTTON);
state.update();
let (now, pre) = state.snapshot();
assert_eq!(now, LEFT_BUTTON | MIDDLE_BUTTON);
assert_eq!(pre, 0);
state.reset();
assert!(!state.is_left_pressed());
assert!(!state.is_middle_pressed());
assert!(!state.is_left_down());
assert!(!state.is_left_up());
assert_eq!(state.snapshot(), (0, 0));
}
}