feat(ui): add mouse wheel scroll

Author: Mivik

prpr/src/judge.rs

@@ -13,7 +13,7 @@ use miniquad::{EventHandler, MouseButton};
 use once_cell::sync::Lazy;
 use sasa::{PlaySfxParams, Sfx};
 use serde::Serialize;
-use std::{cell::RefCell, collections::HashMap, num::FpCategory};
+use std::{cell::RefCell, collections::HashMap, mem, num::FpCategory};
 use tracing::debug;
 
 pub const FLICK_SPEED_THRESHOLD: f32 = 0.8;
@@ -276,9 +276,21 @@ pub struct Judge {
     pub judgements: RefCell<Judgements>,
 }
 
+#[derive(Default)]
+struct TouchStatus {
+    touches: Vec<Touch>,
+    key_delta: i32,
+    keys_down: u32,
+}
+
 static SUBSCRIBER_ID: Lazy<usize> = Lazy::new(register_input_subscriber);
 thread_local! {
-    static TOUCHES: RefCell<(Vec<Touch>, i32, u32)> = RefCell::default();
+    static TOUCHES: RefCell<TouchStatus> = RefCell::default();
+    static WHEEL: RefCell<(f32, f32)> = RefCell::default();
+}
+
+pub fn take_wheel() -> (f32, f32) {
+    WHEEL.with(|it| mem::take(&mut *it.borrow_mut()))
 }
 
 impl Judge {
@@ -332,11 +344,17 @@ impl Judge {
     }
 
     pub(crate) fn on_new_frame() {
-        let mut handler = Handler(Vec::new(), 0, 0);
+        let mut handler = Handler {
+            status: TouchStatus::default(),
+            wheel: (0., 0.),
+        };
         repeat_all_miniquad_input(&mut handler, *SUBSCRIBER_ID);
         handler.finalize();
         TOUCHES.with(|it| {
-            *it.borrow_mut() = (handler.0, handler.1, handler.2);
+            *it.borrow_mut() = handler.status;
+        });
+        WHEEL.with(|it| {
+            *it.borrow_mut() = handler.wheel;
         });
     }
 
@@ -359,7 +377,7 @@ impl Judge {
             let guard = it.borrow();
             let tr = Self::touch_transform(false);
             guard
-                .0
+                .touches
                 .iter()
                 .cloned()
                 .map(|mut it| {
@@ -422,9 +440,9 @@ impl Judge {
         };
         let (events, keys_down) = TOUCHES.with(|it| {
             let guard = it.borrow();
-            (guard.0.clone(), guard.2)
+            (guard.touches.clone(), guard.keys_down)
         });
-        self.key_down_count = self.key_down_count.saturating_add_signed(TOUCHES.with(|it| it.borrow().1));
+        self.key_down_count = self.key_down_count.saturating_add_signed(TOUCHES.with(|it| it.borrow().key_delta));
         {
             fn to_local(Vec2 { x, y }: Vec2) -> Point {
                 Point::new(x / screen_width() * 2. - 1., y / screen_height() * 2. - 1.)
@@ -892,11 +910,14 @@ impl Judge {
     }
 }
 
-struct Handler(Vec<Touch>, i32, u32);
+struct Handler {
+    status: TouchStatus,
+    wheel: (f32, f32),
+}
 impl Handler {
     fn finalize(&mut self) {
         if is_mouse_button_down(MouseButton::Left) {
-            self.0.push(Touch {
+            self.status.touches.push(Touch {
                 id: button_to_id(MouseButton::Left),
                 phase: TouchPhase::Moved,
                 position: mouse_position().into(),
@@ -920,16 +941,21 @@ impl EventHandler for Handler {
     fn update(&mut self, _: &mut miniquad::Context) {}
     fn draw(&mut self, _: &mut miniquad::Context) {}
     fn touch_event(&mut self, _: &mut miniquad::Context, phase: miniquad::TouchPhase, id: u64, x: f32, y: f32, time: f64) {
-        self.0.push(Touch {
+        self.status.touches.push(Touch {
             id,
             phase: phase.into(),
             position: vec2(x, y),
             time,
         });
     }
 
+    fn mouse_wheel_event(&mut self, _ctx: &mut miniquad::Context, x: f32, y: f32) {
+        self.wheel.0 += x;
+        self.wheel.1 += y;
+    }
+
     fn mouse_button_down_event(&mut self, _ctx: &mut miniquad::Context, button: MouseButton, x: f32, y: f32) {
-        self.0.push(Touch {
+        self.status.touches.push(Touch {
             id: button_to_id(button),
             phase: TouchPhase::Started,
             position: vec2(x, y),
@@ -938,7 +964,7 @@ impl EventHandler for Handler {
     }
 
     fn mouse_button_up_event(&mut self, _ctx: &mut miniquad::Context, button: MouseButton, x: f32, y: f32) {
-        self.0.push(Touch {
+        self.status.touches.push(Touch {
             id: button_to_id(button),
             phase: TouchPhase::Ended,
             position: vec2(x, y),
@@ -948,13 +974,13 @@ impl EventHandler for Handler {
 
     fn key_down_event(&mut self, _ctx: &mut miniquad::Context, _keycode: KeyCode, _keymods: miniquad::KeyMods, repeat: bool) {
         if !repeat {
-            self.1 += 1;
-            self.2 += 1;
+            self.status.key_delta += 1;
+            self.status.keys_down += 1;
         }
     }
 
     fn key_up_event(&mut self, _ctx: &mut miniquad::Context, _keycode: KeyCode, _keymods: miniquad::KeyMods) {
-        self.1 -= 1;
+        self.status.key_delta -= 1;
     }
 }
 

prpr/src/ui/scroll.rs

@@ -1,10 +1,18 @@
 use super::{clip_rounded_rect, Ui};
-use crate::core::{Matrix, Point, Vector};
-use macroquad::prelude::{Rect, Touch, TouchPhase, Vec2};
+use crate::{
+    core::{Matrix, Point, Vector},
+    judge::take_wheel,
+};
+use macroquad::{
+    input::mouse_position,
+    prelude::{Rect, Touch, TouchPhase, Vec2},
+    window::{screen_height, screen_width},
+};
 use nalgebra::Translation2;
 use std::collections::VecDeque;
 
 const THRESHOLD: f32 = 0.03;
+const WHEEL_STEP: f32 = 0.1;
 
 pub struct VelocityTracker {
     movements: VecDeque<(f32, Point)>,
@@ -179,12 +187,9 @@ impl Scroller {
         self.touch.map(|it| it.3).unwrap_or_default()
     }
 
-    pub fn update(&mut self, t: f32) {
-        // if !self.frame_touched {
-        // if let Some((id, ..)) = self.touch {
-        // self.touch(id, TouchPhase::Cancelled, 0., 0.);
-        // }
-        // }
+    pub fn update(&mut self, t: f32, extra_scroll: f32) {
+        self.offset += extra_scroll * WHEEL_STEP;
+
         let dt = t - self.last_time;
         self.offset += self.speed * dt;
         const K: f32 = 4.;
@@ -308,7 +313,23 @@ impl Scroll {
     }
 
     pub fn update(&mut self, t: f32) {
-        (if self.horizontal { &mut self.x_scroller } else { &mut self.y_scroller }).update(t)
+        let extra_scroll = if let Some(matrix) = self.matrix {
+            let pt = mouse_position();
+            let pt = matrix.transform_point(&Point::new(pt.0 / screen_width() * 2. - 1., pt.1 / screen_height() * 2. - 1.));
+            if pt.x < 0. || pt.y < 0. || pt.x > self.size.0 || pt.y > self.size.1 {
+                0.
+            } else {
+                let (x, y) = take_wheel();
+                if self.horizontal {
+                    -x
+                } else {
+                    -y
+                }
+            }
+        } else {
+            0.
+        };
+        (if self.horizontal { &mut self.x_scroller } else { &mut self.y_scroller }).update(t, extra_scroll)
     }
 
     pub fn contains(&self, touch: &Touch) -> bool {