boxddd 0.1.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
226
227
228
229
230
231
232
233
234
235
236

use boxddd::{
    BodyDef, BodyType, Error, MotionLocks, QueryFilter, ShapeDef, ShapeProxy, Sphere, Vec3, World,
    WorldDef,
};

#[test]
fn world_runtime_tuning_and_metrics_are_safe() {
    let mut world = World::new(WorldDef::builder().gravity([0.0, -9.8, 0.0]).build()).unwrap();

    world.try_enable_sleeping(false).unwrap();
    assert!(!world.sleeping_enabled());
    world.try_enable_sleeping(true).unwrap();
    assert!(world.sleeping_enabled());

    world.try_enable_continuous(false).unwrap();
    assert!(!world.continuous_enabled());
    world.try_enable_continuous(true).unwrap();
    assert!(world.continuous_enabled());

    world.try_enable_warm_starting(false).unwrap();
    assert!(!world.warm_starting_enabled());
    world.try_enable_warm_starting(true).unwrap();
    assert!(world.warm_starting_enabled());

    world.try_enable_speculative(true).unwrap();
    world.try_set_restitution_threshold(2.0).unwrap();
    assert_eq!(world.restitution_threshold(), 2.0);
    world.try_set_hit_event_threshold(3.0).unwrap();
    assert_eq!(world.hit_event_threshold(), 3.0);
    world.try_set_contact_tuning(60.0, 0.7, 10.0).unwrap();
    world.try_set_contact_recycle_distance(0.02).unwrap();
    assert_eq!(world.contact_recycle_distance(), 0.02);
    world.try_set_maximum_linear_speed(120.0).unwrap();
    assert_eq!(world.maximum_linear_speed(), 120.0);
    world.try_set_worker_count(0).unwrap();
    assert!(world.worker_count() >= 0);

    let counters = world.counters();
    assert_eq!(counters.body_count, 0);
    let profile = world.profile();
    assert!(profile.step >= 0.0);
    let capacity = world.max_capacity();
    assert!(capacity.dynamic_body_count >= 0);
    world.try_rebuild_static_tree().unwrap();
}

#[test]
fn body_runtime_setters_getters_and_buffers_work() {
    let mut world = World::new(WorldDef::builder().gravity([0.0, -9.8, 0.0]).build()).unwrap();
    let body = world.create_body(
        BodyDef::builder()
            .body_type(BodyType::Dynamic)
            .position([0.0, 3.0, 0.0])
            .build(),
    );
    let shape = world.create_sphere_shape(
        body,
        &ShapeDef::builder().density(1.0).build(),
        &Sphere::new([0.0, 0.0, 0.0], 0.5),
    );

    assert_eq!(world.body_type(body), BodyType::Dynamic);
    world.try_set_body_name(body, "runtime-body").unwrap();
    assert_eq!(
        world.try_body_name(body).unwrap().as_deref(),
        Some("runtime-body")
    );

    world
        .try_set_body_transform(body, [1.0, 4.0, 2.0], Default::default())
        .unwrap();
    assert_eq!(world.body_position(body).x, 1.0);
    assert_eq!(world.body_transform(body).p.z, 2.0);
    assert_eq!(world.body_rotation(body), Default::default());

    world
        .try_set_body_linear_velocity(body, [1.0, 2.0, 3.0])
        .unwrap();
    assert_eq!(world.body_linear_velocity(body), Vec3::new(1.0, 2.0, 3.0));
    assert_eq!(
        world
            .try_body_local_point_velocity(body, Vec3::ZERO)
            .unwrap(),
        world.body_linear_velocity(body)
    );
    assert_eq!(
        world
            .try_body_world_point_velocity(body, [1.0, 4.0, 2.0])
            .unwrap(),
        world.body_linear_velocity(body)
    );
    world
        .try_set_body_angular_velocity(body, [0.1, 0.2, 0.3])
        .unwrap();
    assert_eq!(world.body_angular_velocity(body), Vec3::new(0.1, 0.2, 0.3));

    world.try_set_body_linear_damping(body, 0.4).unwrap();
    assert_eq!(world.try_body_linear_damping(body).unwrap(), 0.4);
    world.try_set_body_angular_damping(body, 0.5).unwrap();
    assert_eq!(world.try_body_angular_damping(body).unwrap(), 0.5);
    world.try_set_body_gravity_scale(body, 0.25).unwrap();
    assert_eq!(world.try_body_gravity_scale(body).unwrap(), 0.25);

    let locks = MotionLocks::new(true, false, true, false, true, false);
    world.try_set_body_motion_locks(body, locks).unwrap();
    assert_eq!(world.try_body_motion_locks(body).unwrap(), locks);
    world
        .try_set_body_motion_locks(body, MotionLocks::default())
        .unwrap();
    world.try_set_body_bullet(body, true).unwrap();
    assert!(world.try_body_bullet(body).unwrap());
    world
        .try_enable_body_contact_recycling(body, false)
        .unwrap();
    assert!(!world.try_body_contact_recycling_enabled(body).unwrap());
    world.try_enable_body_hit_events(body, true).unwrap();

    assert!(world.try_body_mass(body).unwrap() > 0.0);
    assert!(world.try_body_inverse_mass(body).unwrap() > 0.0);
    let mass_data = world.try_body_mass_data(body).unwrap();
    world.try_set_body_mass_data(body, mass_data).unwrap();
    world.try_apply_mass_from_shapes(body).unwrap();
    let _ = world.try_body_local_rotational_inertia(body).unwrap();
    let _ = world
        .try_body_world_inverse_rotational_inertia(body)
        .unwrap();
    let _ = world.try_body_local_center_of_mass(body).unwrap();
    let _ = world.try_body_world_center_of_mass(body).unwrap();
    let _ = world.try_body_aabb(body).unwrap();

    world
        .try_apply_force_to_center(body, [1.0, 0.0, 0.0], true)
        .unwrap();
    world
        .try_apply_force(body, [0.0, 1.0, 0.0], world.body_position(body), true)
        .unwrap();
    world.try_apply_torque(body, [0.0, 0.0, 1.0], true).unwrap();
    world
        .try_apply_linear_impulse_to_center(body, [1.0, 0.0, 0.0], true)
        .unwrap();
    world
        .try_apply_linear_impulse(body, [0.0, 1.0, 0.0], world.body_position(body), true)
        .unwrap();
    world
        .try_apply_angular_impulse(body, [0.0, 0.0, 0.1], true)
        .unwrap();
    world.step(1.0 / 60.0, 4);
    assert!(world.body_linear_velocity(body).x > 0.0);

    let mut shapes = vec![shape];
    world.try_body_shapes_into(body, &mut shapes).unwrap();
    assert_eq!(shapes, vec![shape]);
    assert_eq!(world.body_shapes(body), vec![shape]);

    let mut joints = Vec::from([Default::default()]);
    world.try_body_joints_into(body, &mut joints).unwrap();
    assert!(joints.is_empty());

    let mut contacts = vec![Default::default()];
    world.try_body_contacts_into(body, &mut contacts).unwrap();
    assert!(contacts.is_empty());
}

#[test]
fn body_runtime_respects_callback_guard() {
    let mut world = World::new(WorldDef::default()).unwrap();
    let body = world.create_body(BodyDef::default());
    let _guard = boxddd::__private::enter_callback_guard_for_test();

    assert_eq!(
        world.try_body_linear_velocity(body).unwrap_err(),
        boxddd::Error::InCallback
    );
}

#[test]
fn world_rejects_foreign_body_and_shape_handles() {
    let mut world = World::new(WorldDef::default()).unwrap();
    let local = world.create_body(BodyDef::default());

    let mut other = World::new(WorldDef::default()).unwrap();
    let foreign_body = other.create_body(BodyDef::default());
    let foreign_shape = other.create_sphere_shape(
        foreign_body,
        &ShapeDef::default(),
        &Sphere::new(Vec3::ZERO, 0.5),
    );

    assert_eq!(
        world.try_body_position(foreign_body).unwrap_err(),
        Error::InvalidBodyId
    );
    assert_eq!(
        world
            .try_body_closest_point(foreign_body, Vec3::ZERO)
            .unwrap_err(),
        Error::InvalidBodyId
    );
    assert_eq!(
        world
            .try_body_overlap_shape(
                foreign_body,
                Vec3::ZERO,
                &ShapeProxy::sphere(0.5).unwrap(),
                QueryFilter::default()
            )
            .unwrap_err(),
        Error::InvalidBodyId
    );
    assert_eq!(
        world.try_destroy_body(foreign_body).unwrap_err(),
        Error::InvalidBodyId
    );
    assert!(foreign_body.is_valid());
    assert_eq!(
        world
            .try_create_sphere_shape(
                foreign_body,
                &ShapeDef::default(),
                &Sphere::new(Vec3::ZERO, 0.5)
            )
            .unwrap_err(),
        Error::InvalidBodyId
    );
    assert_eq!(
        world.try_shape_body(foreign_shape).unwrap_err(),
        Error::InvalidShapeId
    );
    assert_eq!(
        world.try_destroy_shape(foreign_shape, true).unwrap_err(),
        Error::InvalidShapeId
    );
    assert!(foreign_shape.is_valid());

    world.destroy_body(local);
}