Compiler Explorer

Source code

use core::ops::Add;
use core::iter::Sum;

pub struct MouseWheel {
    /// The mouse scroll unit.
    pub unit: MouseScrollUnit,
    /// The horizontal scroll value.
    pub x: f32,
    /// The vertical scroll value.
    pub y: f32,
    /// Window that received the input.
    pub window: Entity,
}

pub enum MouseScrollUnit {
    /// The line scroll unit.
    ///
    /// The delta of the associated [`MouseWheel`] event corresponds
    /// to the amount of lines or rows to scroll.
    Line,
    /// The pixel scroll unit.
    ///
    /// The delta of the associated [`MouseWheel`] event corresponds
    /// to the amount of pixels to scroll.
    Pixel,
}

pub struct Entity {
    // Do not reorder the fields here. The ordering is explicitly used by repr(C)
    // to make this struct equivalent to a u64.
    #[cfg(target_endian = "little")]
    index: u32,
    generation: u32,
    #[cfg(target_endian = "big")]
    index: u32,
}

pub enum MouseWheelDirection {
    /// Corresponds to `+y`
    Up,
    /// Corresponds to `-y`
    Down,
    /// Corresponds to `+x`
    Right,
    /// Corresponds to `-x`
    Left,
}

pub struct MouseMotion {
    /// The change in the position of the pointing device since the last event was sent.
    pub delta: Vec2,
}

pub enum MouseMotionDirection {
    /// Corresponds to `+y`
    Up,
    /// Corresponds to `-y`
    Down,
    /// Corresponds to `+x`
    Right,
    /// Corresponds to `-x`
    Left,
}

#[derive(Clone, Copy, PartialEq)]
pub struct Vec2 {
    pub x: f32,
    pub y: f32,
}

impl Vec2 {
    const ZERO: Self = Self { x: 0.0, y: 0.0 };
}

impl Add<Vec2> for Vec2 {
    type Output = Self;
    #[inline]
    fn add(self, rhs: Self) -> Self {
        Self {
            x: self.x.add(rhs.x),
            y: self.y.add(rhs.y),
        }
    }
}

impl Sum for Vec2 {
    #[inline]
    fn sum<I>(iter: I) -> Self
    where
        I: Iterator<Item = Self>,
    {
        iter.fold(Self::ZERO, Self::add)
    }
}

pub fn old_wheel(direction: MouseWheelDirection, wheel: Vec<MouseWheel>) -> f32 {
    let mut total_mouse_wheel = 0.0;

for event in wheel {
        total_mouse_wheel += match direction {
            MouseWheelDirection::Up | MouseWheelDirection::Down => {
                event.y
            }
            MouseWheelDirection::Left | MouseWheelDirection::Right => {
                event.x
            }
        }
    };
    total_mouse_wheel
}

pub fn extract_wheel(direction: MouseWheelDirection, wheel: Vec<MouseWheel>) -> f32 {
    let total: f32 = match direction {
        MouseWheelDirection::Up | MouseWheelDirection::Down => {
            wheel.iter().map(|event| event.y).sum()
        }
        MouseWheelDirection::Left | MouseWheelDirection::Right => {
            wheel.iter().map(|event| event.x).sum()
        }
    };
    total
}

pub fn direct_wheel(direction: MouseWheelDirection, wheel: Vec<MouseWheel>) -> f32 {
    let total: Vec2 = wheel
        .iter()
        .map(|event| Vec2 { x: event.x, y: event.y})
        .sum();
    match direction {
        MouseWheelDirection::Up | MouseWheelDirection::Down => {
            total.y
        }
        MouseWheelDirection::Left | MouseWheelDirection::Right => {
            total.x
        }
    }
}

pub fn old_motion(direction: MouseMotionDirection, motions: Vec<MouseMotion>) -> f32 {
    let mut total = 0.0;

for motion in motions {
        total += match direction {
            MouseMotionDirection::Up | MouseMotionDirection::Down => {
                motion.delta.y
            }
            MouseMotionDirection::Left | MouseMotionDirection::Right => {
                motion.delta.x
            }
        }
    };
    total
}

pub fn extract_motion(direction: MouseMotionDirection, motions: Vec<MouseMotion>) -> f32 {
    let total: f32 = match direction {
        MouseMotionDirection::Up | MouseMotionDirection::Down => {
            motions.iter().map(|motion| motion.delta.y).sum()
        }
        MouseMotionDirection::Left | MouseMotionDirection::Right => {
            motions.iter().map(|motion| motion.delta.x).sum()
        }
    };
    total
}

pub fn direct_motion(direction: MouseMotionDirection, motions: Vec<MouseMotion>) -> f32 {
    let total: Vec2 = motions.iter().map(|motion| motion.delta).sum();
    match direction {
        MouseMotionDirection::Up | MouseMotionDirection::Down => {
            total.y
        }
        MouseMotionDirection::Left | MouseMotionDirection::Right => {
            total.x
        }
    }
}