use atomic_float::AtomicF32;
use std::sync::atomic::Ordering;
#[derive(Debug)]
pub(crate) struct ScrollWheelAccumulator {
x: AtomicF32,
y: AtomicF32,
}
impl ScrollWheelAccumulator {
pub(crate) const fn new() -> Self {
Self {
x: AtomicF32::new(0.0),
y: AtomicF32::new(0.0),
}
}
pub(crate) fn merge(&self, x: f32, y: f32) {
if x == 0.0 && y == 0.0 {
return;
}
self.x.fetch_add(x, Ordering::Relaxed);
self.y.fetch_add(y, Ordering::Relaxed);
}
pub(crate) fn take(&self) -> (f32, f32) {
(
self.x.swap(0.0, Ordering::Relaxed),
self.y.swap(0.0, Ordering::Relaxed),
)
}
pub(crate) fn reset(&self) {
self.x.store(0.0, Ordering::Relaxed);
self.y.store(0.0, Ordering::Relaxed);
}
}
impl Default for ScrollWheelAccumulator {
fn default() -> Self {
Self::new()
}
}
#[derive(Debug)]
pub struct ScrollWheel<'el> {
accumulator: &'el ScrollWheelAccumulator,
x: f32,
y: f32,
}
impl<'el> ScrollWheel<'el> {
pub(crate) const fn new(accumulator: &'el ScrollWheelAccumulator) -> Self {
Self {
accumulator,
x: 0.0,
y: 0.0,
}
}
pub fn update(&mut self) {
(self.x, self.y) = self.accumulator.take();
}
pub fn x(&self) -> f32 {
self.x
}
pub fn y(&self) -> f32 {
self.y
}
pub fn snapshot(&self) -> (f32, f32) {
(self.x, self.y)
}
pub fn is_zero(&self) -> bool {
self.x == 0.0 && self.y == 0.0
}
#[expect(dead_code, reason = "maybe use in the future")]
pub(crate) fn reset(&mut self) {
self.accumulator.reset();
self.x = 0.0;
self.y = 0.0;
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn accumulator_merge_take_once() {
let acc = ScrollWheelAccumulator::new();
assert_eq!(acc.take(), (0.0, 0.0));
acc.merge(1.0, 2.0);
acc.merge(3.0, -1.0);
assert_eq!(acc.take(), (4.0, 1.0));
assert_eq!(acc.take(), (0.0, 0.0));
acc.merge(0.0, 0.0);
assert_eq!(acc.take(), (0.0, 0.0));
}
#[test]
fn accumulator_thread_safe() {
use std::sync::Arc;
let acc = Arc::new(ScrollWheelAccumulator::new());
let handles: Vec<_> = (0..8)
.map(|i| {
let acc = Arc::clone(&acc);
std::thread::spawn(move || {
let base = i as f32;
acc.merge(base, -base);
})
})
.collect();
for h in handles {
h.join().unwrap();
}
assert_eq!(acc.take(), (28.0, -28.0));
}
#[test]
fn view_update_cycle() {
let acc = ScrollWheelAccumulator::new();
let mut wheel = ScrollWheel::new(&acc);
wheel.update();
assert!(wheel.is_zero());
assert_eq!(wheel.snapshot(), (0.0, 0.0));
acc.merge(10.0, 5.0);
acc.merge(-3.0, 1.0);
wheel.update();
assert_eq!(wheel.x(), 7.0);
assert_eq!(wheel.y(), 6.0);
assert!(!wheel.is_zero());
wheel.update();
assert!(wheel.is_zero());
assert_eq!(wheel.snapshot(), (0.0, 0.0));
}
#[test]
fn view_reset_clears_both() {
let acc = ScrollWheelAccumulator::new();
let mut wheel = ScrollWheel::new(&acc);
acc.merge(2.0, 3.0);
wheel.reset();
assert!(wheel.is_zero());
assert_eq!(acc.take(), (0.0, 0.0));
}
}