kero 0.1.12

A simple, approachable framework for creating 2D games in Rust and/or Lua.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105

use super::VirtualAxis;
use crate::input::virtual_source::VirtualSource;
use crate::math::{Vec2, vec2};
use std::cell::RefCell;
use std::cmp::Ordering;
use std::fmt::{Debug, Formatter};
use std::rc::Rc;

/// Handle to a virtual stick.
///
/// This combines a virtual x and y axis to simulate a thumbstick, and can be cloned and passed
/// around to give objects access to it.
#[derive(Clone)]
pub struct VirtualStick(Rc<Inner>);

impl Debug for VirtualStick {
    #[inline]
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        f.debug_tuple("VirtualStick").finish_non_exhaustive()
    }
}

impl PartialEq for VirtualStick {
    #[inline]
    fn eq(&self, other: &Self) -> bool {
        Rc::ptr_eq(&self.0, &other.0)
    }
}

impl PartialOrd for VirtualStick {
    #[inline]
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Rc::as_ptr(&self.0).partial_cmp(&Rc::as_ptr(&other.0))
    }
}

struct Inner {
    pub x_axis: RefCell<VirtualAxis>,
    pub y_axis: RefCell<VirtualAxis>,
}

impl VirtualStick {
    /// Create a new stick with no mappings.
    pub fn empty(source: &VirtualSource) -> Self {
        Self::new(source, None, None)
    }

    /// Create a new stick with the provided x and y axes.
    pub fn new(
        source: &VirtualSource,
        x_axis: impl Into<Option<VirtualAxis>>,
        y_axis: impl Into<Option<VirtualAxis>>,
    ) -> Self {
        let x_axis = x_axis.into().unwrap_or_else(|| VirtualAxis::empty(source));
        let y_axis = y_axis.into().unwrap_or_else(|| VirtualAxis::empty(source));
        Self(Rc::new(Inner {
            x_axis: RefCell::new(x_axis),
            y_axis: RefCell::new(y_axis),
        }))
    }

    /// The stick's x-axis.
    #[inline]
    pub fn x_axis(&self) -> VirtualAxis {
        self.0.x_axis.borrow().clone()
    }

    /// The stick's y-axis.
    #[inline]
    pub fn y_axis(&self) -> VirtualAxis {
        self.0.y_axis.borrow().clone()
    }

    /// Set the stick's axes.
    pub fn set_axes(&self, x_axis: VirtualAxis, y_axis: VirtualAxis) {
        *self.0.x_axis.borrow_mut() = x_axis;
        *self.0.y_axis.borrow_mut() = y_axis;
    }

    /// If either axes changed this frame.
    #[inline]
    pub fn changed(&self) -> bool {
        self.0.x_axis.borrow().changed() || self.0.y_axis.borrow().changed()
    }

    /// The stick's non-normalized x-value.
    #[inline]
    pub fn x(&self) -> f32 {
        self.0.x_axis.borrow().value()
    }

    /// The stick's non-normalized y-value.
    #[inline]
    pub fn y(&self) -> f32 {
        self.0.y_axis.borrow().value()
    }

    /// The stick's normalized value.
    #[inline]
    pub fn value(&self) -> Vec2<f32> {
        let value = vec2(self.x(), self.y());
        let len = value.len();
        if len > 1.0 { value / len } else { value }
    }
}