boxddd 0.2.0

Safe, ergonomic Rust bindings for Box3D
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
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225

use super::*;

impl World {
    /// Tries to set the rest length, in world length units, on a distance joint.
    ///
    /// All distance-joint runtime methods return [`Error::WrongJointType`] when
    /// `joint_id` belongs to another joint family, and [`Error::InvalidJointId`]
    /// when the handle is stale or belongs to another world.
    pub fn try_set_distance_joint_length(&mut self, joint_id: JointId, length: f32) -> Result<()> {
        validate_nonnegative_scalar(length)?;
        family_method!(self, joint_id, JointType::Distance, {
            unsafe { ffi::b3DistanceJoint_SetLength(joint_id.into_raw(), length) };
        })
    }

    /// Returns the rest length, in world length units, of a distance joint.
    pub fn try_distance_joint_length(&self, joint_id: JointId) -> Result<f32> {
        family_method!(self, joint_id, JointType::Distance, {
            unsafe { ffi::b3DistanceJoint_GetLength(joint_id.into_raw()) }
        })
    }

    /// Tries to enable or disable the spring on a distance joint.
    pub fn try_enable_distance_joint_spring(
        &mut self,
        joint_id: JointId,
        enabled: bool,
    ) -> Result<()> {
        family_method!(self, joint_id, JointType::Distance, {
            unsafe { ffi::b3DistanceJoint_EnableSpring(joint_id.into_raw(), enabled) };
        })
    }

    /// Returns whether the spring is enabled on a distance joint.
    pub fn try_distance_joint_spring_enabled(&self, joint_id: JointId) -> Result<bool> {
        family_method!(self, joint_id, JointType::Distance, {
            unsafe { ffi::b3DistanceJoint_IsSpringEnabled(joint_id.into_raw()) }
        })
    }

    /// Tries to set the spring force range on a distance joint.
    pub fn try_set_distance_joint_spring_force_range(
        &mut self,
        joint_id: JointId,
        lower: f32,
        upper: f32,
    ) -> Result<()> {
        validate_scalar(lower)?;
        validate_scalar(upper)?;
        family_method!(self, joint_id, JointType::Distance, {
            unsafe { ffi::b3DistanceJoint_SetSpringForceRange(joint_id.into_raw(), lower, upper) };
        })
    }

    /// Returns the spring force range of a distance joint.
    pub fn try_distance_joint_spring_force_range(&self, joint_id: JointId) -> Result<(f32, f32)> {
        family_method!(self, joint_id, JointType::Distance, {
            let mut lower = 0.0;
            let mut upper = 0.0;
            unsafe {
                ffi::b3DistanceJoint_GetSpringForceRange(
                    joint_id.into_raw(),
                    &mut lower,
                    &mut upper,
                )
            };
            (lower, upper)
        })
    }

    /// Tries to set the spring frequency, in hertz, on a distance joint.
    pub fn try_set_distance_joint_spring_hertz(
        &mut self,
        joint_id: JointId,
        hertz: f32,
    ) -> Result<()> {
        validate_nonnegative_scalar(hertz)?;
        family_method!(self, joint_id, JointType::Distance, {
            unsafe { ffi::b3DistanceJoint_SetSpringHertz(joint_id.into_raw(), hertz) };
        })
    }

    /// Returns the spring frequency, in hertz, of a distance joint.
    pub fn try_distance_joint_spring_hertz(&self, joint_id: JointId) -> Result<f32> {
        family_method!(self, joint_id, JointType::Distance, {
            unsafe { ffi::b3DistanceJoint_GetSpringHertz(joint_id.into_raw()) }
        })
    }

    /// Tries to set the dimensionless spring damping ratio on a distance joint.
    pub fn try_set_distance_joint_spring_damping_ratio(
        &mut self,
        joint_id: JointId,
        damping_ratio: f32,
    ) -> Result<()> {
        validate_nonnegative_scalar(damping_ratio)?;
        family_method!(self, joint_id, JointType::Distance, {
            unsafe {
                ffi::b3DistanceJoint_SetSpringDampingRatio(joint_id.into_raw(), damping_ratio)
            };
        })
    }

    /// Returns the dimensionless spring damping ratio of a distance joint.
    pub fn try_distance_joint_spring_damping_ratio(&self, joint_id: JointId) -> Result<f32> {
        family_method!(self, joint_id, JointType::Distance, {
            unsafe { ffi::b3DistanceJoint_GetSpringDampingRatio(joint_id.into_raw()) }
        })
    }

    /// Tries to enable or disable the limit on a distance joint.
    pub fn try_enable_distance_joint_limit(
        &mut self,
        joint_id: JointId,
        enabled: bool,
    ) -> Result<()> {
        family_method!(self, joint_id, JointType::Distance, {
            unsafe { ffi::b3DistanceJoint_EnableLimit(joint_id.into_raw(), enabled) };
        })
    }

    /// Returns whether the limit is enabled on a distance joint.
    pub fn try_distance_joint_limit_enabled(&self, joint_id: JointId) -> Result<bool> {
        family_method!(self, joint_id, JointType::Distance, {
            unsafe { ffi::b3DistanceJoint_IsLimitEnabled(joint_id.into_raw()) }
        })
    }

    /// Tries to set the length range, in world length units, on a distance joint.
    pub fn try_set_distance_joint_length_range(
        &mut self,
        joint_id: JointId,
        min: f32,
        max: f32,
    ) -> Result<()> {
        validate_length_range(min, max)?;
        family_method!(self, joint_id, JointType::Distance, {
            unsafe { ffi::b3DistanceJoint_SetLengthRange(joint_id.into_raw(), min, max) };
        })
    }

    /// Returns the minimum length, in world length units, of a distance joint.
    pub fn try_distance_joint_min_length(&self, joint_id: JointId) -> Result<f32> {
        family_method!(self, joint_id, JointType::Distance, {
            unsafe { ffi::b3DistanceJoint_GetMinLength(joint_id.into_raw()) }
        })
    }

    /// Returns the maximum length, in world length units, of a distance joint.
    pub fn try_distance_joint_max_length(&self, joint_id: JointId) -> Result<f32> {
        family_method!(self, joint_id, JointType::Distance, {
            unsafe { ffi::b3DistanceJoint_GetMaxLength(joint_id.into_raw()) }
        })
    }

    /// Returns the current length, in world length units, of a distance joint.
    pub fn try_distance_joint_current_length(&self, joint_id: JointId) -> Result<f32> {
        family_method!(self, joint_id, JointType::Distance, {
            unsafe { ffi::b3DistanceJoint_GetCurrentLength(joint_id.into_raw()) }
        })
    }

    /// Tries to enable or disable the motor on a distance joint.
    pub fn try_enable_distance_joint_motor(
        &mut self,
        joint_id: JointId,
        enabled: bool,
    ) -> Result<()> {
        family_method!(self, joint_id, JointType::Distance, {
            unsafe { ffi::b3DistanceJoint_EnableMotor(joint_id.into_raw(), enabled) };
        })
    }

    /// Returns whether the motor is enabled on a distance joint.
    pub fn try_distance_joint_motor_enabled(&self, joint_id: JointId) -> Result<bool> {
        family_method!(self, joint_id, JointType::Distance, {
            unsafe { ffi::b3DistanceJoint_IsMotorEnabled(joint_id.into_raw()) }
        })
    }

    /// Tries to set the motor speed, in length units per second, on a distance joint.
    pub fn try_set_distance_joint_motor_speed(
        &mut self,
        joint_id: JointId,
        speed: f32,
    ) -> Result<()> {
        validate_scalar(speed)?;
        family_method!(self, joint_id, JointType::Distance, {
            unsafe { ffi::b3DistanceJoint_SetMotorSpeed(joint_id.into_raw(), speed) };
        })
    }

    /// Returns the motor speed, in length units per second, of a distance joint.
    pub fn try_distance_joint_motor_speed(&self, joint_id: JointId) -> Result<f32> {
        family_method!(self, joint_id, JointType::Distance, {
            unsafe { ffi::b3DistanceJoint_GetMotorSpeed(joint_id.into_raw()) }
        })
    }

    /// Tries to set the maximum motor force, in newtons, on a distance joint.
    pub fn try_set_distance_joint_max_motor_force(
        &mut self,
        joint_id: JointId,
        force: f32,
    ) -> Result<()> {
        validate_nonnegative_scalar(force)?;
        family_method!(self, joint_id, JointType::Distance, {
            unsafe { ffi::b3DistanceJoint_SetMaxMotorForce(joint_id.into_raw(), force) };
        })
    }

    /// Returns the maximum motor force, in newtons, of a distance joint.
    pub fn try_distance_joint_max_motor_force(&self, joint_id: JointId) -> Result<f32> {
        family_method!(self, joint_id, JointType::Distance, {
            unsafe { ffi::b3DistanceJoint_GetMaxMotorForce(joint_id.into_raw()) }
        })
    }

    /// Returns the current motor force, in newtons, of a distance joint.
    pub fn try_distance_joint_motor_force(&self, joint_id: JointId) -> Result<f32> {
        family_method!(self, joint_id, JointType::Distance, {
            unsafe { ffi::b3DistanceJoint_GetMotorForce(joint_id.into_raw()) }
        })
    }
}