Updated style

Fixed style

configure

@@ -172,9 +172,6 @@ def write_makefile(modules):
 modules = [Bin("oculus-info", ["oculus-vr"]),
            LibMakefile("libovr_wrapper.a", "src/oculus-vr/", "src/oculus-vr/libovr_wrapper.a", ["cgmath", "libOculusVR.a"]),
            LibCMake("libOculusVR.a", "modules/OculusSDK/LibOVR/", "modules/OculusSDK/LibOVR/libOculusVR.a"),
-           #Bin("steamworks-info", ["steamworks-vr"], other_flags="-L thirdparty/Steamworks/redistributable_bin/linux64/"),
-           #Lib("steamworks-vr", ["cgmath", "libsteamvr_wrapper.a"]),
-           #LibMakefile("libsteamvr_wrapper.a", "src/steamworks-vr/", "src/steamworks-vr/libsteamvr_wrapper.a"),
            Lib("cgmath")]
 
 if platform.system() == "Linux":

src/oculus-info/main.rs

@@ -2,17 +2,43 @@
 
 extern crate ovr = "oculus-vr";
 
-fn main()
-{
+fn main() {
     ovr::init();
 
-    let dm = ovr::DeviceManager::new().unwrap();
-    let dev = dm.enumerate().unwrap();
+    let dm = match ovr::DeviceManager::new() {
+        Some(dm) => dm,
+        None => {
+            println!("Could not initialize Oculus Device Manager");
+            return;
+        }
+    };
+
+    let dev = match dm.enumerate() {
+        Some(d) => d,
+        None => {
+            println!("Could not enumerate Oculus HMD.");
+            println!("Was it unplugged?");
+            return;
+        }
+    };
+
+    let sf = match ovr::SensorFusion::new() {
+        Some(sf) => sf,
+        None => {
+            println!("Could not allocate Sensor Fusion")
+            return;
+        }
+    };
+
+    let sensor = match dev.get_sensor() {
+        Some(sensor) => sensor,
+        None => {
+            println!("Could not get the sensor from HMD");
+            return;
+        }
+    };
+
     let info = dev.get_info();
-
-    let sf = ovr::SensorFusion::new().unwrap();
-    let sensor = dev.get_sensor().unwrap();
-
     sf.attach_to_sensor(&sensor);
 
     match info.resolution() {

src/oculus-vr/lib.rs

@@ -23,6 +23,7 @@ use cgmath::angle::rad;
 #[link(name="Xinerama")]
 #[link(name="edid")]
 #[link(name="Xrandr")]
+#[link(name="X11")]
 extern {}
 
 #[cfg(target_os = "macos")]
@@ -58,8 +59,7 @@ pub mod ll {
     }
 
     impl Clone for HMDInfo {
-        fn clone(&self) -> HMDInfo
-        {
+        fn clone(&self) -> HMDInfo {
             HMDInfo {
                 horizontal_resolution: self.horizontal_resolution,
                 vertical_resolution: self.vertical_resolution,
@@ -167,8 +167,7 @@ pub struct DeviceManager {
 }
 
 impl Drop for DeviceManager {
-    fn drop(&mut self)
-    {
+    fn drop(&mut self) {
         unsafe {
             ll::OVR_DeviceManager_drop(self.ptr);
         }
@@ -176,8 +175,7 @@ impl Drop for DeviceManager {
 }
 
 impl DeviceManager {
-    pub fn new() -> Option<DeviceManager>
-    {
+    pub fn new() -> Option<DeviceManager> {
         unsafe {
             let ptr = ll::OVR_DeviceManager_Create();
 
@@ -191,8 +189,7 @@ impl DeviceManager {
         }
     }
 
-    pub fn enumerate(&self) -> Option<HMDDevice>
-    {
+    pub fn enumerate(&self) -> Option<HMDDevice> {
         unsafe {
             let ptr = ll::OVR_DeviceManager_EnumerateDevices(self.ptr);
 
@@ -212,8 +209,7 @@ pub struct HMDDevice {
 }
 
 impl HMDDevice {
-    pub fn get_info(&self) -> HMDInfo
-    {
+    pub fn get_info(&self) -> HMDInfo {
         unsafe {
             HMDInfo{
                 dat: ll::OVR_HMDDevice_GetDeviceInfo(self.ptr)
@@ -221,8 +217,7 @@ impl HMDDevice {
         }        
     }
 
-    pub fn get_sensor(&self) -> Option<SensorDevice>
-    {
+    pub fn get_sensor(&self) -> Option<SensorDevice> {
         unsafe {
             let ptr = ll::OVR_HMDDevice_GetSensor(self.ptr);
 
@@ -245,66 +240,55 @@ pub struct HMDInfo {
 
 impl HMDInfo
 {
-    pub fn resolution(&self) -> (uint, uint)
-    {
+    pub fn resolution(&self) -> (uint, uint) {
         (self.dat.horizontal_resolution as uint, self.dat.vertical_resolution as uint)
     }
 
-    pub fn size(&self) -> (f32, f32)
-    {
+    pub fn size(&self) -> (f32, f32) {
         (self.dat.horizontal_screen_size as f32, self.dat.vertical_screen_size as f32)
     }
 
-    pub fn desktop(&self) -> (int, int)
-    {
+    pub fn desktop(&self) -> (int, int) {
         (self.dat.desktop_x as int, self.dat.desktop_y as int)
     }
 
-    pub fn vertical_center(&self) -> f32
-    {
+    pub fn vertical_center(&self) -> f32 {
         self.dat.vertical_screen_center as f32
     }
 
-    pub fn eye_to_screen_distance(&self) -> f32
-    {
+    pub fn eye_to_screen_distance(&self) -> f32 {
         self.dat.eye_to_screen_distance as f32
     }
 
-    pub fn lens_separation_distance(&self) -> f32
-    {
+    pub fn lens_separation_distance(&self) -> f32 {
         self.dat.lens_separation_distance as f32
     }
 
-    pub fn interpupillary_distance(&self) -> f32
-    {
+    pub fn interpupillary_distance(&self) -> f32 {
         self.dat.interpupillary_distance as f32
     }
 
-    pub fn distortion_K(&self) -> [f32, ..4]
-    {
+    pub fn distortion_K(&self) -> [f32, ..4] {
         [self.dat.distortion_k[0] as f32,
          self.dat.distortion_k[1] as f32,
          self.dat.distortion_k[2] as f32,
          self.dat.distortion_k[3] as f32]
     }
 
-    pub fn chroma_ab_correction(&self) -> [f32, ..4]
-    {
+    pub fn chroma_ab_correction(&self) -> [f32, ..4] {
         [self.dat.chroma_ab_correction[0] as f32,
          self.dat.chroma_ab_correction[1] as f32,
          self.dat.chroma_ab_correction[2] as f32,
          self.dat.chroma_ab_correction[3] as f32]
     }
 
-    pub fn name(&self) -> ~str
-    {
+    pub fn name(&self) -> ~str {
         unsafe {
         std::str::raw::from_c_str(&self.dat.display_device_name[0])
         }
     }
 
-    pub fn id(&self) -> int
-    {
+    pub fn id(&self) -> int {
         self.dat.display_id as int
     }
 }
@@ -322,8 +306,7 @@ impl Drop for SensorFusion {
 }
 
 impl SensorFusion {
-    pub fn new() -> Option<SensorFusion>
-    {
+    pub fn new() -> Option<SensorFusion> {
         unsafe {
             let ptr = ll::OVR_SensorFusion();
 
@@ -337,30 +320,26 @@ impl SensorFusion {
         } 
     }
 
-    pub fn attach_to_sensor(&self, sensor: &SensorDevice) -> bool
-    {
+    pub fn attach_to_sensor(&self, sensor: &SensorDevice) -> bool {
         unsafe {
             ll::OVR_SensorFusion_AttachToSensor(self.ptr, sensor.ptr)
         } 
     }
 
-    pub fn is_attached_to_sensor(&self) -> bool
-    {
+    pub fn is_attached_to_sensor(&self) -> bool {
         unsafe {
             ll::OVR_SensorFusion_IsAttachedToSensor(self.ptr)
         }
     }
 
-    pub fn get_orientation(&self) -> Quaternion<f32>
-    {
+    pub fn get_orientation(&self) -> Quaternion<f32> {
         unsafe {
             let out = ll::OVR_SensorFusion_GetOrientation(self.ptr);
             Quaternion::new(out.w, out.x, out.y, out.z)
         }
     }
 
-    pub fn get_predicted_orientation(&self, dt: Option<f32>) -> Quaternion<f32>
-    {
+    pub fn get_predicted_orientation(&self, dt: Option<f32>) -> Quaternion<f32> {
         unsafe {
             let out = match dt {
                 Some(dt) => ll::OVR_SensorFusion_GetPredictedOrientation_opt(self.ptr, dt as c_float),
@@ -370,147 +349,127 @@ impl SensorFusion {
         }
     }
 
-    pub fn get_acceleration(&self) -> Vector3<f32>
-    {
+    pub fn get_acceleration(&self) -> Vector3<f32> {
         unsafe {
             let out = ll::OVR_SensorFusion_GetAcceleration(self.ptr);
             Vector3::new(out.x, out.y, out.z)
         }
     }
 
-    pub fn get_angular_velocity(&self) -> Vector3<f32>
-    {
+    pub fn get_angular_velocity(&self) -> Vector3<f32> {
         unsafe {
             let out = ll::OVR_SensorFusion_GetAngularVelocity(self.ptr);
             Vector3::new(out.x, out.y, out.z)
         }
     }
 
-    pub fn get_magnetometer(&self) -> Vector3<f32>
-    {
+    pub fn get_magnetometer(&self) -> Vector3<f32> {
         unsafe {
             let out = ll::OVR_SensorFusion_GetMagnetometer(self.ptr);
             Vector3::new(out.x, out.y, out.z)
         }
     }
 
-    pub fn get_calibrated_magnetometer(&self) -> Vector3<f32>
-    {
+    pub fn get_calibrated_magnetometer(&self) -> Vector3<f32> {
         unsafe {
             let out = ll::OVR_SensorFusion_GetCalibratedMagnetometer(self.ptr);
             Vector3::new(out.x, out.y, out.z)
         }
     }
 
-    pub fn reset(&self)
-    {
+    pub fn reset(&self) {
         unsafe {
             ll::OVR_SensorFusion_Reset(self.ptr);
         }
     }
 
-    pub fn enable_motion_tracking(&self, enable: bool)
-    {
+    pub fn enable_motion_tracking(&self, enable: bool) {
         unsafe {
             ll::OVR_SensorFusion_EnableMotionTracking(self.ptr, enable)
         }
     }
 
-    pub fn is_motion_tracking_enabled(&self) -> bool
-    {
+    pub fn is_motion_tracking_enabled(&self) -> bool {
         unsafe {
             ll::OVR_SensorFusion_IsMotionTrackingEnabled(self.ptr)
         }
     }
 
-    pub fn get_prediction_delta(&self) -> f32
-    {
+    pub fn get_prediction_delta(&self) -> f32 {
         unsafe {
             ll::OVR_SensorFusion_GetPredictionDelta(self.ptr) as f32
         }
     }
 
-    pub fn set_prediction(&self, dt: f32, enable: bool)
-    {
+    pub fn set_prediction(&self, dt: f32, enable: bool) {
         unsafe {
             ll::OVR_SensorFusion_SetPrediction(self.ptr, dt as c_float, enable)
         }
     }
 
-    pub fn set_prediction_enabled(&self, enable: bool)
-    {
+    pub fn set_prediction_enabled(&self, enable: bool) {
         unsafe {
             ll::OVR_SensorFusion_SetPredictionEnabled(self.ptr, enable)
         }
     }
 
-    pub fn is_prediction_enabled(&self) -> bool
-    {
+    pub fn is_prediction_enabled(&self) -> bool {
         unsafe {
             ll::OVR_SensorFusion_IsPredictionEnabled(self.ptr)
         }       
     }
 
-    pub fn set_gravity_enabled(&self, enable_gravity: bool)
-    {
+    pub fn set_gravity_enabled(&self, enable_gravity: bool) {
         unsafe {
             ll::OVR_SensorFusion_SetGravityEnabled(self.ptr, enable_gravity)
         }
     }
 
-    pub fn is_gravity_enabled(&self) -> bool
-    {
+    pub fn is_gravity_enabled(&self) -> bool {
         unsafe {
             ll::OVR_SensorFusion_IsGravityEnabled(self.ptr)
         }
     }
 
-    pub fn get_accel_gain(&self) -> f32
-    {
+    pub fn get_accel_gain(&self) -> f32 {
         unsafe {
             ll::OVR_SensorFusion_GetAccelGain(self.ptr) as f32
         }
     }
 
-    pub fn set_accel_gain(&self, ag: f32)
-    {
+    pub fn set_accel_gain(&self, ag: f32) {
         unsafe {
             ll::OVR_SensorFusion_SetAccelGain(self.ptr, ag as c_float)
         }
     }
 
-    pub fn save_mag_calibration(&self, calibration_name: &str) -> bool
-    {
+    pub fn save_mag_calibration(&self, calibration_name: &str) -> bool {
         let cn = calibration_name.to_c_str();
         unsafe {
             ll::OVR_SensorFusion_SaveMagCalibration(self.ptr, cn.unwrap())
         }
     }
 
-    pub fn load_mag_calibration(&self, calibration_name: &str) -> bool
-    {
+    pub fn load_mag_calibration(&self, calibration_name: &str) -> bool {
         let cn = calibration_name.to_c_str();
         unsafe {
             ll::OVR_SensorFusion_LoadMagCalibration(self.ptr, cn.unwrap())
         }
     }
 
-    pub fn set_yaw_correction_enabled(&self, enable: bool)
-    {
+    pub fn set_yaw_correction_enabled(&self, enable: bool) {
         unsafe {
             ll::OVR_SensorFusion_SetYawCorrectionEnabled(self.ptr, enable)
         }
     }
 
-    pub fn is_yaw_correction_enabled(&self) -> bool
-    {
+    pub fn is_yaw_correction_enabled(&self) -> bool {
         unsafe {
             ll::OVR_SensorFusion_IsYawCorrectionEnabled(self.ptr)
         }
     }
 
-    pub fn set_mag_calibration(&self, m: &Matrix4<f32>)
-    {
+    pub fn set_mag_calibration(&self, m: &Matrix4<f32>) {
         let mat = ll::Matrix4f{
             m11: m.x.x as c_float, m12: m.x.y as c_float, m13: m.x.z as c_float, m14: m.x.w as c_float,
             m21: m.y.x as c_float, m22: m.y.y as c_float, m23: m.y.z as c_float, m24: m.y.w as c_float,
@@ -523,8 +482,7 @@ impl SensorFusion {
         }
     }
 
-    pub fn get_mag_calibration(&self) -> Matrix4<f32>
-    {
+    pub fn get_mag_calibration(&self) -> Matrix4<f32> {
         unsafe {
             let m = ll::OVR_SensorFusion_GetMagCalibration(self.ptr);
 
@@ -536,29 +494,25 @@ impl SensorFusion {
     }
 
     /// TODO this should not return a time_t!
-    pub fn get_mag_calibration_time(&self) -> time_t
-    {
+    pub fn get_mag_calibration_time(&self) -> time_t {
         unsafe {
             ll::OVR_SensorFusion_GetMagCalibrationTime(self.ptr)
         }
     }
 
-    pub fn has_mag_calibration(&self) -> bool
-    {
+    pub fn has_mag_calibration(&self) -> bool {
         unsafe {
             ll::OVR_SensorFusion_HasMagCalibration(self.ptr)
         }
     }
 
-    pub fn clear_mag_calibration(&self)
-    {
+    pub fn clear_mag_calibration(&self) {
         unsafe {
             ll::OVR_SensorFusion_ClearMagCalibration(self.ptr)
         }
     }
 
-    pub fn clear_mag_references(&self, vec: &Vector3<f32>)
-    {
+    pub fn clear_mag_references(&self, vec: &Vector3<f32>) {
         let vec = ll::Vector3f{x: vec.x, y: vec.y, z: vec.z};
 
         unsafe {
@@ -566,8 +520,7 @@ impl SensorFusion {
         }
     }
 
-    pub fn get_calibrated_mag_value(&self) -> Vector3<f32>
-    {
+    pub fn get_calibrated_mag_value(&self) -> Vector3<f32> {
         unsafe {
             let vec = ll::OVR_SensorFusion_GetCalibratedMagValue(self.ptr);
             Vector3::new(vec.x, vec.y, vec.z)
@@ -580,10 +533,8 @@ pub struct SensorDevice {
     msg: Option<*ll::MessageHandler>
 }
 
-impl Drop for SensorDevice
-{
-    fn drop(&mut self)
-    {
+impl Drop for SensorDevice {
+    fn drop(&mut self) {
         unsafe {
             ll::OVR_SensorDevice_drop(self.ptr); 
         }

src/oculus-vr/wrapper.cpp

@@ -43,16 +43,14 @@ extern "C"
     };
 
 
-    class RustMessageHandler : public OVR::MessageHandler
-    {
+    class RustMessageHandler : public OVR::MessageHandler {
     public:
         RustMessageHandler(void *_ptr, void (*_BodyFrame)(void *ptr, struct MessageBodyFrame *msg)) {
             ptr = _ptr;
             BodyFrame = _BodyFrame;
         }
 
-        void OnMessage(const OVR::Message& msg)
-        {
+        void OnMessage(const OVR::Message& msg) {
             if (msg.Type == OVR::Message_BodyFrame) {
                 const OVR::MessageBodyFrame& bf = static_cast<const OVR::MessageBodyFrame&>(msg);
                 struct MessageBodyFrame mbf = {
@@ -70,45 +68,37 @@ extern "C"
         void (*BodyFrame)(void *ptr, struct MessageBodyFrame *msg);
     };
 
-    RustMessageHandler* OVR_MessageHandler(void *_ptr, void (*_BodyFrame)(void *ptr, struct MessageBodyFrame *msg))
-    {
+    RustMessageHandler* OVR_MessageHandler(void *_ptr, void (*_BodyFrame)(void *ptr, struct MessageBodyFrame *msg)) {
         return new RustMessageHandler(_ptr, _BodyFrame);
     }
 
-    void* OVR_MessageHandler_move_ptr(RustMessageHandler* mh)
-    {
+    void* OVR_MessageHandler_move_ptr(RustMessageHandler* mh) {
         void *ptr = mh->ptr;
         mh->ptr = NULL;
         return ptr;
     }
 
-    void OVR_MessageHandler_drop(RustMessageHandler* mh)
-    {
+    void OVR_MessageHandler_drop(RustMessageHandler* mh) {
         delete mh;
     }
 
-    void OVR_system_init(void)
-    {
+    void OVR_system_init(void) {
         OVR::System::Init(OVR::Log::ConfigureDefaultLog(OVR::LogMask_All));
     }
 
-    OVR::DeviceManager* OVR_DeviceManager_Create(void)
-    {
+    OVR::DeviceManager* OVR_DeviceManager_Create(void) {
         return OVR::DeviceManager::Create();
     }
 
-    void OVR_DeviceManager_drop(OVR::DeviceManager *dm)
-    {
+    void OVR_DeviceManager_drop(OVR::DeviceManager *dm) {
         delete dm;
     }
 
-    OVR::HMDDevice* OVR_DeviceManager_EnumerateDevices(OVR::DeviceManager* pManager)
-    {
+    OVR::HMDDevice* OVR_DeviceManager_EnumerateDevices(OVR::DeviceManager* pManager) {
         return pManager->EnumerateDevices<OVR::HMDDevice>().CreateDevice();
     }
 
-    struct HMDInfoC OVR_HMDDevice_GetDeviceInfo(OVR::HMDDevice* pHMD)
-    {
+    struct HMDInfoC OVR_HMDDevice_GetDeviceInfo(OVR::HMDDevice* pHMD) {
         OVR::HMDInfo hmd;
         struct HMDInfoC out_hmd;
         pHMD->GetDeviceInfo(&hmd);
@@ -131,158 +121,130 @@ extern "C"
         return out_hmd;
     }
 
-    OVR::SensorDevice* OVR_HMDDevice_GetSensor(OVR::HMDDevice* pHMD)
-    {
+    OVR::SensorDevice* OVR_HMDDevice_GetSensor(OVR::HMDDevice* pHMD) {
         return pHMD->GetSensor();
     }
 
-    void OVR_SensorDevice_drop(OVR::SensorDevice* sd)
-    {
+    void OVR_SensorDevice_drop(OVR::SensorDevice* sd) {
         delete sd;
     }
 
-    void OVR_SensorDevice_SetMessageHandler(OVR::SensorDevice* sensor, RustMessageHandler* mh)
-    {
+    void OVR_SensorDevice_SetMessageHandler(OVR::SensorDevice* sensor, RustMessageHandler* mh) {
         sensor->SetMessageHandler(mh);
     }
 
-    OVR::SensorFusion* OVR_SensorFusion(OVR::HMDDevice* pHMD)
-    {
+    OVR::SensorFusion* OVR_SensorFusion(OVR::HMDDevice* pHMD) {
         OVR::SensorFusion* SFusion = new OVR::SensorFusion;
         return SFusion;
     }
 
-    bool OVR_SensorFusion_IsAttachedToSensor(OVR::SensorFusion *sf)
-    {
+    bool OVR_SensorFusion_IsAttachedToSensor(OVR::SensorFusion *sf) {
         return sf->IsAttachedToSensor();
     }
 
-    Quatf OVR_SensorFusion_GetOrientation(OVR::SensorFusion *sf)
-    {
+    Quatf OVR_SensorFusion_GetOrientation(OVR::SensorFusion *sf) {
         OVR::Quatf quat = sf->GetOrientation();
         Quatf out = {quat.x, quat.y, quat.z, quat.w};
         return out;
     }
 
-    Quatf OVR_SensorFusion_GetPredictedOrientation(OVR::SensorFusion *sf)
-    {
+    Quatf OVR_SensorFusion_GetPredictedOrientation(OVR::SensorFusion *sf) {
         OVR::Quatf quat = sf->GetPredictedOrientation();
         Quatf out = {quat.x, quat.y, quat.z, quat.w};
         return out;
     }
 
-    Quatf OVR_SensorFusion_GetPredictedOrientation_opt(OVR::SensorFusion *sf, float dt)
-    {
+    Quatf OVR_SensorFusion_GetPredictedOrientation_opt(OVR::SensorFusion *sf, float dt) {
         OVR::Quatf quat = sf->GetPredictedOrientation(dt);
         Quatf out = {quat.x, quat.y, quat.z, quat.w};
         return out;    
     }
 
-    Vector3f OVR_SensorFusion_GetAcceleration(OVR::SensorFusion *sf)
-    {
+    Vector3f OVR_SensorFusion_GetAcceleration(OVR::SensorFusion *sf) {
         OVR::Vector3f vec = sf->GetAcceleration();
         Vector3f out = {vec.x, vec.y, vec.z};
         return out; 
     }
 
-    Vector3f OVR_SensorFusion_GetAngularVelocity(OVR::SensorFusion *sf)
-    {
+    Vector3f OVR_SensorFusion_GetAngularVelocity(OVR::SensorFusion *sf) {
         OVR::Vector3f vec = sf->GetAngularVelocity();
         Vector3f out = {vec.x, vec.y, vec.z};
         return out; 
     }
 
-    Vector3f OVR_SensorFusion_GetMagnetometer(OVR::SensorFusion *sf)
-    {
+    Vector3f OVR_SensorFusion_GetMagnetometer(OVR::SensorFusion *sf) {
         OVR::Vector3f vec = sf->GetMagnetometer();
         Vector3f out = {vec.x, vec.y, vec.z};
         return out; 
     }
 
-    Vector3f OVR_SensorFusion_GetCalibratedMagnetometer(OVR::SensorFusion *sf)
-    {
+    Vector3f OVR_SensorFusion_GetCalibratedMagnetometer(OVR::SensorFusion *sf) {
         OVR::Vector3f vec = sf->GetCalibratedMagnetometer();
         Vector3f out = {vec.x, vec.y, vec.z};
         return out; 
     }
 
-    void OVR_SensorFusion_Reset(OVR::SensorFusion *sf)
-    {
+    void OVR_SensorFusion_Reset(OVR::SensorFusion *sf) {
         sf->Reset();
     }
 
-    void OVR_SensorFusion_EnableMotionTracking(OVR::SensorFusion *sf, bool enable)
-    {
+    void OVR_SensorFusion_EnableMotionTracking(OVR::SensorFusion *sf, bool enable) {
         sf->EnableMotionTracking(enable);
     }
 
-    bool OVR_SensorFusion_IsMotionTrackingEnabled(OVR::SensorFusion *sf)
-    {
+    bool OVR_SensorFusion_IsMotionTrackingEnabled(OVR::SensorFusion *sf) {
         return sf->IsMotionTrackingEnabled();
     }
 
-    float OVR_SensorFusion_GetPredictionDelta(OVR::SensorFusion *sf)
-    {
+    float OVR_SensorFusion_GetPredictionDelta(OVR::SensorFusion *sf) {
         return sf->GetPredictionDelta();
     }
 
-    void OVR_SensorFusion_SetPrediction(OVR::SensorFusion *sf, float dt, bool enable)
-    {
+    void OVR_SensorFusion_SetPrediction(OVR::SensorFusion *sf, float dt, bool enable) {
         sf->SetPrediction(dt, enable);
     }
 
-    void OVR_SensorFusion_SetPredictionEnabled(OVR::SensorFusion *sf, bool enable)
-    {
+    void OVR_SensorFusion_SetPredictionEnabled(OVR::SensorFusion *sf, bool enable) {
         sf->SetPredictionEnabled(enable);
     }
 
-    bool OVR_SensorFusion_IsPredictionEnabled(OVR::SensorFusion *sf)
-    {
+    bool OVR_SensorFusion_IsPredictionEnabled(OVR::SensorFusion *sf) {
         return sf->IsPredictionEnabled();
     }
 
-    void OVR_SensorFusion_SetGravityEnabled(OVR::SensorFusion *sf, bool enableGravity)
-    {
+    void OVR_SensorFusion_SetGravityEnabled(OVR::SensorFusion *sf, bool enableGravity) {
         sf->SetGravityEnabled(enableGravity);
     }
 
-    bool OVR_SensorFusion_IsGravityEnabled(OVR::SensorFusion *sf)
-    {
+    bool OVR_SensorFusion_IsGravityEnabled(OVR::SensorFusion *sf) {
         return sf->IsGravityEnabled();
     }
 
-    float OVR_SensorFusion_GetAccelGain(OVR::SensorFusion *sf)
-    {
+    float OVR_SensorFusion_GetAccelGain(OVR::SensorFusion *sf) {
         return sf->GetAccelGain();
     }
 
-    void OVR_SensorFusion_SetAccelGain(OVR::SensorFusion *sf, float ag)
-    {
+    void OVR_SensorFusion_SetAccelGain(OVR::SensorFusion *sf, float ag) {
         return sf->SetAccelGain(ag);
     }
 
-    bool OVR_SensorFusion_SaveMagCalibration(OVR::SensorFusion *sf, const char *calibrationName)
-    {
+    bool OVR_SensorFusion_SaveMagCalibration(OVR::SensorFusion *sf, const char *calibrationName) {
         return sf->SaveMagCalibration(calibrationName);
     }
 
-    bool OVR_SensorFusion_LoadMagCalibration(OVR::SensorFusion *sf, const char *calibrationName)
-    {
+    bool OVR_SensorFusion_LoadMagCalibration(OVR::SensorFusion *sf, const char *calibrationName) {
         return sf->LoadMagCalibration(calibrationName);
     }
 
-    void OVR_SensorFusion_SetYawCorrectionEnabled(OVR::SensorFusion *sf, bool enable)
-    {
+    void OVR_SensorFusion_SetYawCorrectionEnabled(OVR::SensorFusion *sf, bool enable) {
         sf->SetYawCorrectionEnabled(enable);
     }
 
-    bool OVR_SensorFusion_IsYawCorrectionEnabled(OVR::SensorFusion *sf)
-    {
+    bool OVR_SensorFusion_IsYawCorrectionEnabled(OVR::SensorFusion *sf) {
         return sf->IsYawCorrectionEnabled();
     }
 
-    void OVR_SensorFusion_SetMagCalibration(OVR::SensorFusion *sf, Matrix4f *m)
-    {
+    void OVR_SensorFusion_SetMagCalibration(OVR::SensorFusion *sf, Matrix4f *m) {
         OVR::Matrix4f mat = OVR::Matrix4f(m->m11, m->m12, m->m13, m->m14,
                                           m->m21, m->m22, m->m23, m->m24,
                                           m->m31, m->m32, m->m33, m->m34,
@@ -290,8 +252,7 @@ extern "C"
         sf->SetMagCalibration(mat);
     }
 
-    Matrix4f OVR_SensorFusion_GetMagCalibration(OVR::SensorFusion *sf)
-    {
+    Matrix4f OVR_SensorFusion_GetMagCalibration(OVR::SensorFusion *sf) {
         OVR::Matrix4f m = sf->GetMagCalibration();
         Matrix4f out = {
             m.M[0][0], m.M[0][1], m.M[0][2], m.M[0][3],
@@ -302,28 +263,23 @@ extern "C"
         return out;
     }
 
-    time_t OVR_SensorFusion_GetMagCalibrationTime(OVR::SensorFusion *sf)
-    {
+    time_t OVR_SensorFusion_GetMagCalibrationTime(OVR::SensorFusion *sf) {
         return sf->GetMagCalibrationTime();
     }
 
-    bool OVR_SensorFusion_HasMagCalibration(OVR::SensorFusion *sf)
-    {
+    bool OVR_SensorFusion_HasMagCalibration(OVR::SensorFusion *sf) {
         return sf->HasMagCalibration();
     }
 
-    void OVR_SensorFusion_ClearMagCalibration(OVR::SensorFusion *sf)
-    {
+    void OVR_SensorFusion_ClearMagCalibration(OVR::SensorFusion *sf) {
         sf->ClearMagCalibration();
     }
 
-    void OVR_SensorFusion_ClearMagReferences(OVR::SensorFusion *sf)
-    {
+    void OVR_SensorFusion_ClearMagReferences(OVR::SensorFusion *sf) {
         sf->ClearMagReferences();
     }
 
-    Vector3f OVR_SensorFusion_GetCalibratedMagValue(OVR::SensorFusion *sf, const Vector3f *rawMag)
-    {
+    Vector3f OVR_SensorFusion_GetCalibratedMagValue(OVR::SensorFusion *sf, const Vector3f *rawMag) {
         OVR::Vector3f input = OVR::Vector3f(rawMag->x, rawMag->y, rawMag->z);
         OVR::Vector3f vec = sf->GetCalibratedMagValue(input);
         Vector3f out = {vec.x, vec.y, vec.z};
@@ -331,13 +287,11 @@ extern "C"
     }
 
 
-    bool OVR_SensorFusion_AttachToSensor(OVR::SensorFusion* SFusion, OVR::SensorDevice *pSensor)
-    {
+    bool OVR_SensorFusion_AttachToSensor(OVR::SensorFusion* SFusion, OVR::SensorDevice *pSensor) {
         return (*SFusion).AttachToSensor(pSensor);
     }
 
-    void OVR_SensorFusion_OnMessage(OVR::SensorFusion* SFusion, const MessageBodyFrame *msg)
-    {
+    void OVR_SensorFusion_OnMessage(OVR::SensorFusion* SFusion, const MessageBodyFrame *msg) {
         OVR::MessageBodyFrame sensor(NULL);
 
         sensor.TimeDelta = msg->TimeDelta;
@@ -350,8 +304,7 @@ extern "C"
         SFusion->OnMessage(sensor);
     }
 
-    void OVR_SensorFusion_drop(OVR::SensorFusion *sf)
-    {
+    void OVR_SensorFusion_drop(OVR::SensorFusion *sf) {
         delete sf;
     }
 }