Add simulate_touch_with_mouse

src/input.rs

@@ -87,6 +87,18 @@ pub fn simulate_mouse_with_touch(option: bool) {
     get_context().simulate_mouse_with_touch = option;
 }
 
+/// This is set to false by default, meaning mouse events will NOT raise touch events in addition to raising mouse events.
+/// If set to true, mouse events WILL raise touch events in addition to raising mouse events.
+pub fn is_simulating_touch_with_mouse() -> bool {
+    get_context().simulate_touch_with_mouse
+}
+
+/// This is set to false by default, meaning mouse events will NOT raise touch events in addition to raising mouse events.
+/// If set to true, mouse events WILL raise touch events in addition to raising mouse events.
+pub fn simulate_touch_with_mouse(option: bool) {
+    get_context().simulate_touch_with_mouse = option;
+}
+
 /// Return touches with positions in pixels.
 pub fn touches() -> Vec<Touch> {
     get_context().touches.values().cloned().collect()

src/lib.rs

@@ -181,6 +181,7 @@
     screen_height: f32,
 
     simulate_mouse_with_touch: bool,
+    simulate_touch_with_mouse: bool,
 
     keys_down: HashSet<KeyCode>,
     keys_pressed: HashSet<KeyCode>,
@@ -215,7 +216,7 @@
     last_frame_time: f64,
     frame_time: f64,
 
     #[cfg(one_screenshot)]
     counter: usize,
 
     camera_stack: Vec<camera::CameraState>,
@@ -321,7 +322,8 @@
             screen_height,
 
             simulate_mouse_with_touch: true,
-
+            simulate_touch_with_mouse: false,
+
             keys_down: HashSet::new(),
             keys_pressed: HashSet::new(),
             keys_released: HashSet::new(),
@@ -363,7 +365,7 @@
             last_frame_time: miniquad::date::now(),
             frame_time: 1. / 60.,
 
             #[cfg(one_screenshot)]
             counter: 0,
             unwind: false,
             recovery_future: None,
@@ -420,7 +422,7 @@
 
         get_quad_context().commit_frame();
 
         #[cfg(one_screenshot)]
         {
             get_context().counter += 1;
             if get_context().counter == 3 {
@@ -497,17 +499,17 @@
 fn get_context() -> &'static mut Context {
     thread_assert::same_thread();
 
     unsafe { CONTEXT.as_mut().unwrap_or_else(|| panic!()) }
 }
 
 fn get_quad_context() -> &'static mut dyn miniquad::RenderingBackend {
     thread_assert::same_thread();
 
     unsafe {
         assert!(CONTEXT.is_some());
     }
 
     unsafe { &mut *CONTEXT.as_mut().unwrap().quad_context }
 }
 
 struct Stage {
@@ -554,6 +556,29 @@
                 .for_each(|arr| arr.push(MiniquadInputEvent::MouseMotion { x, y }));
         }
 
+        // Generate touch events when simulate_touch_with_mouse is enabled
+        // Only generate move events if the left mouse button is down
+        if context.simulate_touch_with_mouse && context.mouse_down.contains(&MouseButton::Left) {
+            let id = 0; // Use a consistent ID for mouse-simulated touch
+            context.touches.insert(
+                id,
+                input::Touch {
+                    id,
+                    phase: input::TouchPhase::Moved,
+                    position: Vec2::new(x, y),
+                },
+            );
+
+            context.input_events.iter_mut().for_each(|arr| {
+                arr.push(MiniquadInputEvent::Touch {
+                    phase: TouchPhase::Moved,
+                    id,
+                    x,
+                    y,
+                })
+            });
+        }
+
         if context.update_on.mouse_motion {
             miniquad::window::schedule_update();
         }
@@ -590,6 +615,28 @@
             context.mouse_position = Vec2::new(x, y);
         }
 
+        // Generate touch events when simulate_touch_with_mouse is enabled
+        if context.simulate_touch_with_mouse && btn == MouseButton::Left {
+            let id = 0; // Use a consistent ID for mouse-simulated touch
+            context.touches.insert(
+                id,
+                input::Touch {
+                    id,
+                    phase: input::TouchPhase::Started,
+                    position: Vec2::new(x, y),
+                },
+            );
+
+            context.input_events.iter_mut().for_each(|arr| {
+                arr.push(MiniquadInputEvent::Touch {
+                    phase: TouchPhase::Started,
+                    id,
+                    x,
+                    y,
+                })
+            });
+        }
+
         if context.update_on.mouse_down {
             miniquad::window::schedule_update();
         }
@@ -609,6 +656,29 @@
         if !context.cursor_grabbed {
             context.mouse_position = Vec2::new(x, y);
         }
+
+        // Generate touch events when simulate_touch_with_mouse is enabled
+        if context.simulate_touch_with_mouse && btn == MouseButton::Left {
+            let id = 0; // Use a consistent ID for mouse-simulated touch
+            context.touches.insert(
+                id,
+                input::Touch {
+                    id,
+                    phase: input::TouchPhase::Ended,
+                    position: Vec2::new(x, y),
+                },
+            );
+
+            context.input_events.iter_mut().for_each(|arr| {
+                arr.push(MiniquadInputEvent::Touch {
+                    phase: TouchPhase::Ended,
+                    id,
+                    x,
+                    y,
+                })
+            });
+        }
+
         if context.update_on.mouse_up {
             miniquad::window::schedule_update();
         }
@@ -932,7 +1002,7 @@
                 main_future: Box::pin(async {
                     future.await;
                     unsafe {
                         if let Some(ctx) = CONTEXT.as_mut() {
                             ctx.gl.reset();
                         }
                     }