use minifb::Key;
use std::sync::atomic::{AtomicUsize, Ordering};
const USIZE_COUNT: usize = (Key::Count as usize).div_ceil(usize::BITS as usize);
#[derive(Debug)]
pub(crate) struct KeyStateDirtyMap {
raw: [AtomicUsize; USIZE_COUNT],
}
impl KeyStateDirtyMap {
pub(crate) const fn new() -> Self {
const INIT: AtomicUsize = AtomicUsize::new(0);
Self {
raw: [INIT; USIZE_COUNT],
}
}
pub(crate) fn merge(&self, keys: &[Key]) {
let mut masks = [0usize; USIZE_COUNT];
for &key in keys {
let (slot, bit) = Self::slot_bit(key);
masks[slot] |= bit;
}
for (slot, mask) in masks.iter().enumerate() {
if *mask == 0 {
continue;
}
let mut old = self.raw[slot].load(Ordering::SeqCst);
loop {
let new = old | mask;
match self.raw[slot].compare_exchange(old, new, Ordering::SeqCst, Ordering::SeqCst)
{
Ok(_) => break,
Err(current) => old = current,
}
}
}
}
pub(crate) fn take(&self) -> [usize; USIZE_COUNT] {
let mut result = [0usize; USIZE_COUNT];
for (slot, r) in result.iter_mut().enumerate() {
*r = self.raw[slot].swap(0, Ordering::SeqCst);
}
result
}
#[inline]
fn slot_bit(key: Key) -> (usize, usize) {
let idx = key as usize;
let slot = idx / (usize::BITS as usize);
let bit = 1usize << (idx % (usize::BITS as usize));
(slot, bit)
}
#[allow(unused)]
fn reset(&self) {
for slot in 0..USIZE_COUNT {
self.raw[slot].store(0, Ordering::Relaxed);
}
}
}
impl Default for KeyStateDirtyMap {
fn default() -> Self {
Self::new()
}
}
#[derive(Debug)]
pub struct KeyState<'el> {
dirty_map: &'el KeyStateDirtyMap,
now: [usize; USIZE_COUNT],
pre: [usize; USIZE_COUNT],
}
impl<'el> KeyState<'el> {
pub(crate) const fn new(dirty_map: &'el KeyStateDirtyMap) -> Self {
Self {
dirty_map,
now: [0; USIZE_COUNT],
pre: [0; USIZE_COUNT],
}
}
pub fn update(&mut self) {
self.pre.copy_from_slice(&self.now);
self.now = self.dirty_map.take();
}
#[inline]
fn now_bit(&self, key: Key) -> bool {
let (slot, bit) = KeyStateDirtyMap::slot_bit(key);
self.now[slot] & bit != 0
}
#[inline]
fn pre_bit(&self, key: Key) -> bool {
let (slot, bit) = KeyStateDirtyMap::slot_bit(key);
self.pre[slot] & bit != 0
}
pub fn is_down(&self, key: Key) -> bool {
self.now_bit(key) && !self.pre_bit(key)
}
pub fn is_up(&self, key: Key) -> bool {
!self.now_bit(key) && self.pre_bit(key)
}
pub fn is_pressed(&self, key: Key) -> bool {
self.now_bit(key)
}
pub fn snapshot(&self) -> ([usize; USIZE_COUNT], [usize; USIZE_COUNT]) {
(self.now, self.pre)
}
#[expect(dead_code, reason = "maybe use in the future")]
pub(crate) fn reset(&mut self) {
self.dirty_map.reset();
self.now = [0; USIZE_COUNT];
self.pre = [0; USIZE_COUNT];
}
}
#[cfg(test)]
mod tests {
use super::*;
use minifb::Key;
#[test]
fn dirty_map_merge_take_once() {
let map = KeyStateDirtyMap::new();
assert_eq!(map.take(), [0usize; USIZE_COUNT]);
map.merge(&[Key::A]);
map.merge(&[Key::A, Key::Space, Key::Enter]);
let taken = map.take();
for key in [Key::A, Key::Space, Key::Enter] {
let (slot, bit) = KeyStateDirtyMap::slot_bit(key);
assert_ne!(taken[slot] & bit, 0, "{key:?} 应被置位");
}
assert_eq!(map.take(), [0usize; USIZE_COUNT]);
}
#[test]
fn dirty_map_reset() {
let map = KeyStateDirtyMap::new();
map.merge(&[Key::A, Key::B]);
map.reset();
assert_eq!(map.take(), [0usize; USIZE_COUNT]);
}
#[test]
fn dirty_map_thread_safe() {
use std::sync::Arc;
let map = Arc::new(KeyStateDirtyMap::new());
let keys = [
Key::A,
Key::B,
Key::C,
Key::D,
Key::E,
Key::F,
Key::G,
Key::H,
];
let handles: Vec<_> = keys
.iter()
.map(|&k| {
let m = Arc::clone(&map);
std::thread::spawn(move || m.merge(&[k]))
})
.collect();
for h in handles {
h.join().unwrap();
}
let taken = map.take();
for key in keys {
let (slot, bit) = KeyStateDirtyMap::slot_bit(key);
assert_ne!(taken[slot] & bit, 0, "{key:?} 应被置位");
}
}
#[test]
fn edge_detection_sequence() {
let map = KeyStateDirtyMap::new();
let mut state = KeyState::new(&map);
state.update();
assert!(!state.is_down(Key::A));
assert!(!state.is_up(Key::A));
assert!(!state.is_pressed(Key::A));
map.merge(&[Key::A]);
state.update();
assert!(state.is_down(Key::A));
assert!(state.is_pressed(Key::A));
assert!(!state.is_up(Key::A));
map.merge(&[Key::A]);
state.update();
assert!(!state.is_down(Key::A));
assert!(state.is_pressed(Key::A));
assert!(!state.is_up(Key::A));
state.update();
assert!(state.is_up(Key::A));
assert!(!state.is_pressed(Key::A));
assert!(!state.is_down(Key::A));
}
#[test]
fn merge_only_takes_effect_after_update() {
let map = KeyStateDirtyMap::new();
let mut state = KeyState::new(&map);
state.update();
map.merge(&[Key::B]);
assert!(!state.is_pressed(Key::B));
state.update();
assert!(state.is_pressed(Key::B));
}
#[test]
fn multiple_keys_are_independent() {
let map = KeyStateDirtyMap::new();
let mut state = KeyState::new(&map);
state.update();
map.merge(&[Key::A, Key::C]);
state.update();
assert!(state.is_down(Key::A));
assert!(state.is_down(Key::C));
assert!(!state.is_down(Key::B));
map.merge(&[Key::B, Key::C]);
state.update();
assert!(state.is_up(Key::A));
assert!(state.is_down(Key::B));
assert!(state.is_pressed(Key::C));
assert!(!state.is_down(Key::C));
}
#[test]
fn snapshot_and_reset() {
let map = KeyStateDirtyMap::new();
let mut state = KeyState::new(&map);
state.update();
map.merge(&[Key::Space]);
state.update();
let (now, pre) = state.snapshot();
let (slot, bit) = KeyStateDirtyMap::slot_bit(Key::Space);
assert_ne!(now[slot] & bit, 0);
assert_eq!(pre[slot] & bit, 0);
state.reset();
assert!(!state.is_pressed(Key::Space));
assert!(!state.is_down(Key::Space));
assert!(!state.is_up(Key::Space));
assert_eq!(
state.snapshot(),
([0usize; USIZE_COUNT], [0usize; USIZE_COUNT])
);
}
}