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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126

use wrap::*;
use common::math::Vec2;
use user_data::UserDataTypes;
use dynamics::world::{World, BodyHandle};
use dynamics::joints::{Joint, JointType, JointDef};

pub struct MouseJointDef {
    pub body_a: BodyHandle,
    pub body_b: BodyHandle,
    pub collide_connected: bool,
    pub target: Vec2,
    pub max_force: f32,
    pub frequency: f32,
    pub damping_ratio: f32,
}

impl MouseJointDef {
    pub fn new(body_a: BodyHandle, body_b: BodyHandle) -> MouseJointDef {
        MouseJointDef {
            body_a: body_a,
            body_b: body_b,
            collide_connected: false,
            target: Vec2 { x: 0., y: 0. },
            max_force: 0.,
            frequency: 5.,
            damping_ratio: 0.7,
        }
    }
}

impl JointDef for MouseJointDef {
    fn joint_type() -> JointType
        where Self: Sized
    {
        JointType::Mouse
    }

    unsafe fn create<U: UserDataTypes>(&self, world: &mut World<U>) -> *mut ffi::Joint {
        self.try_create(world).expect("joint create failed: invalid body handle")
    }

    unsafe fn try_create<U: UserDataTypes>(&self, world: &mut World<U>) -> Option<*mut ffi::Joint> {
        Some(ffi::World_create_mouse_joint(world.mut_ptr(),
                                           world.try_body_mut(self.body_a)?.mut_ptr(),
                                           world.try_body_mut(self.body_b)?.mut_ptr(),
                                           self.collide_connected,
                                           self.target,
                                           self.max_force,
                                           self.frequency,
                                           self.damping_ratio))
    }
}

wrap_joint! {
    ffi::MouseJoint => MouseJoint (JointType::Mouse)
    < ffi::MouseJoint_as_joint
    > ffi::Joint_as_mouse_joint
}

impl MouseJoint {
    pub fn target<'a>(&'a self) -> &'a Vec2 {
        unsafe {
            &*ffi::MouseJoint_get_target(self.ptr()) // Comes from a C++ &
        }
    }

    pub fn max_force(&self) -> f32 {
        unsafe { ffi::MouseJoint_get_max_force(self.ptr()) }
    }

    pub fn frequency(&self) -> f32 {
        unsafe { ffi::MouseJoint_get_frequency(self.ptr()) }
    }

    pub fn damping_ratio(&self) -> f32 {
        unsafe { ffi::MouseJoint_get_damping_ratio(self.ptr()) }
    }

    pub fn set_target(&mut self, target: &Vec2) {
        unsafe { ffi::MouseJoint_set_target(self.mut_ptr(), target) }
    }

    pub fn set_max_force(&mut self, force: f32) {
        unsafe { ffi::MouseJoint_set_max_force(self.mut_ptr(), force) }
    }

    pub fn set_frequency(&mut self, frequency: f32) {
        unsafe { ffi::MouseJoint_set_frequency(self.mut_ptr(), frequency) }
    }

    pub fn set_damping_ratio(&mut self, ratio: f32) {
        unsafe { ffi::MouseJoint_set_damping_ratio(self.mut_ptr(), ratio) }
    }
}

#[doc(hidden)]
pub mod ffi {
    pub use dynamics::world::ffi::World;
    pub use dynamics::body::ffi::Body;
    pub use dynamics::joints::ffi::Joint;
    use common::math::Vec2;

    pub enum MouseJoint {}

    extern "C" {
        pub fn World_create_mouse_joint(world: *mut World,
                                        body_a: *mut Body,
                                        body_b: *mut Body,
                                        collide_connected: bool,
                                        target: Vec2,
                                        max_force: f32,
                                        frequency: f32,
                                        damping_ratio: f32)
                                        -> *mut Joint;
        pub fn MouseJoint_as_joint(slf: *mut MouseJoint) -> *mut Joint;
        pub fn Joint_as_mouse_joint(slf: *mut Joint) -> *mut MouseJoint;
        pub fn MouseJoint_set_target(slf: *mut MouseJoint, target: *const Vec2);
        pub fn MouseJoint_get_target(slf: *const MouseJoint) -> *const Vec2;
        pub fn MouseJoint_set_max_force(slf: *mut MouseJoint, force: f32);
        pub fn MouseJoint_get_max_force(slf: *const MouseJoint) -> f32;
        pub fn MouseJoint_set_frequency(slf: *mut MouseJoint, hz: f32);
        pub fn MouseJoint_get_frequency(slf: *const MouseJoint) -> f32;
        pub fn MouseJoint_set_damping_ratio(slf: *mut MouseJoint, ratio: f32);
        pub fn MouseJoint_get_damping_ratio(slf: *const MouseJoint) -> f32;
    }
}