gamepad_motion/
lib.rs

1#![allow(unused)]
2use autocxx::{prelude::*, subclass::CppSubclassSelfOwnedDefault};
3use std::pin::Pin;
4
5// override for std::pin::pin!, which doesn't seem to behave the same as Pin::new(&mut)
6macro_rules! pin {
7    ($value:expr $(,)?) => {
8        std::pin::Pin::new(&mut $value)
9    };
10}
11
12include_cpp! {
13    #include "GamepadMotion.hpp"
14    generate!("GamepadMotion")
15    generate!("GamepadMotionSettings")
16    generate!("GamepadMotionHelpers::GyroCalibration")
17    generate!("GamepadMotionHelpers::AutoCalibration")
18    generate!("GamepadMotionHelpers::Motion")
19    safety!(unsafe_ffi)
20}
21
22type CalibrationMode = ffi::GamepadMotionHelpers::CalibrationMode;
23
24pub struct GamepadMotion(UniquePtr<ffi::GamepadMotion>);
25
26impl GamepadMotion {
27    #[inline]
28    pub fn new() -> Self {
29        Self(ffi::GamepadMotion::new().within_unique_ptr())
30    }
31
32    #[inline]
33    pub fn gyro_player_space(&mut self, yaw_relax_factor: Option<f32>) -> [f32; 2] {
34        let (mut x, mut y) = (0f32, 0f32);
35        self.0
36            .pin_mut()
37            .GetPlayerSpaceGyro(pin!(x), pin!(y), yaw_relax_factor.unwrap_or(1.41));
38        [x, y]
39    }
40
41    #[inline]
42    pub fn gyro_calibrated(&mut self) -> [f32; 3] {
43        let (mut x, mut y, mut z) = (0f32, 0f32, 0f32);
44        self.0
45            .pin_mut()
46            .GetCalibratedGyro(pin!(x), pin!(y), pin!(z));
47        [x, y, z]
48    }
49
50    #[inline]
51    pub fn gyro_world_space(&mut self, side_reduc_thresh: Option<f32>) -> [f32; 2] {
52        let (mut x, mut y) = (0f32, 0f32);
53        self.0
54            .pin_mut()
55            .GetWorldSpaceGyro(pin!(x), pin!(y), side_reduc_thresh.unwrap_or(0.125));
56        [x, y]
57    }
58
59    #[inline]
60    pub fn process(&mut self, g: [f32; 3], a: [f32; 3], dt: &f32) -> &mut Self {
61        self.0
62            .pin_mut()
63            .ProcessMotion(g[0], g[1], g[2], a[0], a[1], a[2], *dt);
64        self
65    }
66
67    #[inline]
68    pub fn calib_mode_set(&mut self, c: CalibrationMode) {
69        self.0.pin_mut().SetCalibrationMode(c);
70    }
71
72    #[inline]
73    pub fn calib_mode(&mut self) -> CalibrationMode {
74        self.0.pin_mut().GetCalibrationMode()
75    }
76
77    #[inline]
78    pub fn calib_offset_set(&mut self, xyz: [f32; 3], w: i32) {
79        self.0
80            .pin_mut()
81            .SetCalibrationOffset(xyz[0], xyz[1], xyz[2], w.into());
82    }
83
84    #[inline]
85    pub fn calib_offset(&mut self) -> [f32; 3] {
86        let (mut x, mut y, mut z) = (0f32, 0f32, 0f32);
87        self.0
88            .pin_mut()
89            .GetCalibrationOffset(pin!(x), pin!(y), pin!(z));
90        [x, y, z]
91    }
92
93    #[inline]
94    pub fn orientation(&mut self) -> [f32; 4] {
95        let (mut x, mut y, mut z, mut w) = (0f32, 0f32, 0f32, 0f32);
96        self.0
97            .pin_mut()
98            .GetOrientation(pin!(w), pin!(x), pin!(y), pin!(z));
99        [x, y, z, w]
100    }
101
102    #[inline]
103    pub fn gravity(&mut self) -> [f32; 3] {
104        let (mut x, mut y, mut z) = (0f32, 0f32, 0f32);
105        self.0.pin_mut().GetGravity(pin!(x), pin!(y), pin!(z));
106        [x, y, z]
107    }
108
109    #[inline]
110    pub fn accel_processed(&mut self) -> [f32; 3] {
111        let (mut x, mut y, mut z) = (0f32, 0f32, 0f32);
112        self.0
113            .pin_mut()
114            .GetProcessedAcceleration(pin!(x), pin!(y), pin!(z));
115        [x, y, z]
116    }
117
118    #[inline]
119    pub fn calib_cont_start(&mut self) {
120        self.0.pin_mut().StartContinuousCalibration();
121    }
122
123    #[inline]
124    pub fn calib_cont_pause(&mut self) {
125        self.0.pin_mut().PauseContinuousCalibration();
126    }
127
128    #[inline]
129    pub fn calib_cont_reset(&mut self) {
130        self.0.pin_mut().ResetContinuousCalibration();
131    }
132
133    #[inline]
134    pub fn calib_auto_steady(&mut self) -> bool {
135        self.0.pin_mut().GetAutoCalibrationIsSteady()
136    }
137
138    #[inline]
139    pub fn calib_auto_confid(&mut self) -> f32 {
140        self.0.pin_mut().GetAutoCalibrationConfidence()
141    }
142
143    #[inline]
144    pub fn calib_auto_confid_set(&mut self, confid: f32) {
145        self.0.pin_mut().SetAutoCalibrationConfidence(confid);
146    }
147
148    #[inline]
149    pub fn reset(&mut self) {
150        self.0.pin_mut().Reset();
151    }
152
153    #[inline]
154    pub fn reset_motion(&mut self) {
155        self.0.pin_mut().ResetMotion();
156    }
157}
158
159struct Settings(UniquePtr<ffi::GamepadMotionSettings>);
160
161impl Settings {
162    #[inline]
163    pub fn new() -> Self {
164        Self(ffi::GamepadMotionSettings::new().within_unique_ptr())
165    }
166}
167
168struct AutoCalibration(UniquePtr<ffi::GamepadMotionHelpers::AutoCalibration>);
169
170impl AutoCalibration {
171    #[inline]
172    pub fn new() -> Self {
173        Self(ffi::GamepadMotionHelpers::AutoCalibration::new().within_unique_ptr())
174    }
175
176    #[inline]
177    pub fn steady(&mut self) -> bool {
178        self.0.pin_mut().IsSteady()
179    }
180
181    #[inline]
182    pub fn reset(&mut self) {
183        self.0.pin_mut().Reset();
184    }
185}
186
187struct GyroCalibration(UniquePtr<ffi::GamepadMotionHelpers::GyroCalibration>);
188
189struct Motion(UniquePtr<ffi::GamepadMotionHelpers::Motion>);
190
191struct Vec(UniquePtr<ffi::GamepadMotionHelpers::Vec>);
192
193#[cfg(test)]
194mod tests {
195    use super::*;
196}
gamepad_motion/lib.rs

gamepad_motion/
lib.rs
