box3d-rust 0.2.1

Pure Rust port of the Box3D 3D physics engine
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

// b3World_Step from physics_world.c, split out of world/mod.rs to keep
// modules focused.
//
// SPDX-FileCopyrightText: 2025 Erin Catto
// SPDX-License-Identifier: MIT

use crate::world::{Profile, World};

impl World {
    /// Advance the world simulation by one time step. (b3World_Step)
    pub fn step(&mut self, time_step: f32, sub_step_count: i32) {
        use crate::broad_phase::update_broad_phase_pairs;
        use crate::math_functions::{is_valid_float, max_int, min_float};
        use crate::solver::{make_soft, solve, StepContext};

        debug_assert!(is_valid_float(time_step) && time_step >= 0.0);
        debug_assert!(!self.locked);
        if self.locked {
            return;
        }

        crate::recording::capture::rec(self, |rec, wid| {
            rec.write_step(wid, time_step, sub_step_count);
        });

        self.locked = true;

        self.body_move_events.clear();
        self.sensor_begin_events.clear();
        self.contact_begin_events.clear();
        self.contact_hit_events.clear();
        self.joint_events.clear();
        self.profile = Profile::default();

        {
            let c = &mut self.max_capacity;
            c.static_shape_count = max_int(
                c.static_shape_count,
                self.broad_phase.trees[crate::types::BodyType::Static as usize].proxy_count(),
            );
            c.dynamic_shape_count = max_int(
                c.dynamic_shape_count,
                self.broad_phase.trees[crate::types::BodyType::Dynamic as usize].proxy_count(),
            );
            let static_body_count = self.solver_sets[crate::solver_set::STATIC_SET as usize]
                .body_sims
                .len() as i32;
            c.static_body_count = max_int(c.static_body_count, static_body_count);
            let total_body_count = self.body_id_pool.id_count();
            c.dynamic_body_count =
                max_int(c.dynamic_body_count, total_body_count - static_body_count);
            c.contact_count = max_int(c.contact_count, self.contact_id_pool.id_count());
        }

        update_broad_phase_pairs(self);

        let sub_steps = max_int(1, sub_step_count);
        let mut context = StepContext {
            dt: time_step,
            sub_step_count: sub_steps,
            ..StepContext::default()
        };

        if time_step > 0.0 {
            context.inv_dt = 1.0 / time_step;
            context.h = time_step / sub_steps as f32;
            context.inv_h = sub_steps as f32 * context.inv_dt;
        } else {
            context.inv_dt = 0.0;
            context.h = 0.0;
            context.inv_h = 0.0;
        }

        self.inv_dt = context.inv_dt;
        self.inv_h = context.inv_h;

        // Hertz values get reduced for large time steps
        let contact_hertz = min_float(self.contact_hertz, 0.125 * context.inv_h);
        context.contact_softness = make_soft(contact_hertz, self.contact_damping_ratio, context.h);
        context.static_softness = make_soft(
            2.0 * contact_hertz,
            0.5 * self.contact_damping_ratio,
            context.h,
        );
        context.restitution_threshold = self.restitution_threshold;
        context.max_linear_velocity = self.max_linear_speed;
        context.contact_speed = self.contact_speed;
        context.enable_warm_starting = self.enable_warm_starting;

        crate::contact::collide(self, time_step);

        if time_step > 0.0 {
            solve(self, &context);
        }

        // Update sensors (after solve; C physics_world.c runs b3OverlapSensors here)
        crate::sensor::overlap_sensors(self);

        self.step_index = self.step_index.wrapping_add(1);
        self.validate_solver_sets();

        // Swap end event array buffers
        self.end_event_array_index = 1 - self.end_event_array_index;
        self.sensor_end_events[self.end_event_array_index as usize].clear();
        self.contact_end_events[self.end_event_array_index as usize].clear();
        self.locked = false;

        if self.recording.is_some() {
            use crate::math_functions::aabb_union;
            use crate::recording::hash::hash_world_state;
            use crate::recording::session::world_public_id;
            use crate::types::BODY_TYPE_COUNT;

            let hash = hash_world_state(self);
            let wid = world_public_id(self);
            crate::recording::with_recording(self, |rec| {
                rec.write_state_hash(wid, hash);
            });

            let mut world_bounds = crate::math_functions::Aabb::default();
            let mut have_bounds = false;
            for i in 0..BODY_TYPE_COUNT {
                let tree = &self.broad_phase.trees[i];
                if tree.proxy_count() == 0 {
                    continue;
                }
                let bounds = tree.root_bounds();
                world_bounds = if have_bounds {
                    aabb_union(world_bounds, bounds)
                } else {
                    bounds
                };
                have_bounds = true;
            }
            if have_bounds {
                crate::recording::with_recording(self, |rec| {
                    rec.accumulate_bounds(world_bounds);
                });
            }
        }
    }
}