nichkara/rapier
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #83 from rezural/harness-testbed-integration

Browse Source 
Harness testbed integration
This commit is contained in:
Sébastien Crozet
2021-01-08 18:26:30 +01:00
committed by GitHub
parent fd3b4801b6 5ca82eeaee
commit 0f3d68d518
14 changed files with 300 additions and 296 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
examples2d/add_remove2.rs
View File

@@ -10,7 +10,7 @@ pub fn init_world(testbed: &mut Testbed) {
let rad = 0.5; let rad = 0.5;
// Callback that will be executed on the main loop to handle proximities. // Callback that will be executed on the main loop to handle proximities.
testbed.add_callback(move |window, physics, _, graphics, _| { testbed.add_callback(move |mut window, mut graphics, physics, _, _| {
let rigid_body = RigidBodyBuilder::new_dynamic() let rigid_body = RigidBodyBuilder::new_dynamic()
.translation(0.0, 10.0) .translation(0.0, 10.0)
.build(); .build();
@@ -19,7 +19,10 @@ pub fn init_world(testbed: &mut Testbed) {
physics physics
.colliders .colliders
.insert(collider, handle, &mut physics.bodies); .insert(collider, handle, &mut physics.bodies);
graphics.add(window, handle, &physics.bodies, &physics.colliders);
if let (Some(graphics), Some(window)) = (&mut graphics, &mut window) {
graphics.add(*window, handle, &physics.bodies, &physics.colliders);
}
let to_remove: Vec<_> = physics let to_remove: Vec<_> = physics
.bodies .bodies
@@ -31,7 +34,10 @@ pub fn init_world(testbed: &mut Testbed) {
physics physics
.bodies .bodies
.remove(handle, &mut physics.colliders, &mut physics.joints); .remove(handle, &mut physics.colliders, &mut physics.joints);
graphics.remove_body_nodes(window, handle);
if let (Some(graphics), Some(window)) = (&mut graphics, &mut window) {
graphics.remove_body_nodes(*window, handle);
}
} }
}); });

6
examples2d/platform2.rs
View File

@@ -60,13 +60,13 @@ pub fn init_world(testbed: &mut Testbed) {
/* /*
* Setup a callback to control the platform. * Setup a callback to control the platform.
*/ */
testbed.add_callback(move |_, physics, _, _, time| { testbed.add_callback(move |_, _, physics, _, run_state| {
let platform = physics.bodies.get_mut(platform_handle).unwrap(); let platform = physics.bodies.get_mut(platform_handle).unwrap();
let mut next_pos = *platform.position(); let mut next_pos = *platform.position();
let dt = 0.016; let dt = 0.016;
next_pos.translation.vector.y += (time * 5.0).sin() * dt; next_pos.translation.vector.y += (run_state.time * 5.0).sin() * dt;
next_pos.translation.vector.x += time.sin() * 5.0 * dt; next_pos.translation.vector.x += run_state.time.sin() * 5.0 * dt;
if next_pos.translation.vector.x >= rad * 10.0 { if next_pos.translation.vector.x >= rad * 10.0 {
next_pos.translation.vector.x -= dt; next_pos.translation.vector.x -= dt;

5
examples2d/sensor2.rs
View File

@@ -69,7 +69,7 @@ pub fn init_world(testbed: &mut Testbed) {
testbed.set_body_color(sensor_handle, Point3::new(0.5, 1.0, 1.0)); testbed.set_body_color(sensor_handle, Point3::new(0.5, 1.0, 1.0));
// Callback that will be executed on the main loop to handle proximities. // Callback that will be executed on the main loop to handle proximities.
testbed.add_callback(move |_, physics, events, graphics, _| { testbed.add_callback(move |_, mut graphics, physics, events, _| {
while let Ok(prox) = events.proximity_events.try_recv() { while let Ok(prox) = events.proximity_events.try_recv() {
let color = match prox.new_status { let color = match prox.new_status {
Proximity::WithinMargin | Proximity::Intersecting => Point3::new(1.0, 1.0, 0.0), Proximity::WithinMargin | Proximity::Intersecting => Point3::new(1.0, 1.0, 0.0),
@@ -78,7 +78,7 @@ pub fn init_world(testbed: &mut Testbed) {
let parent_handle1 = physics.colliders.get(prox.collider1).unwrap().parent(); let parent_handle1 = physics.colliders.get(prox.collider1).unwrap().parent();
let parent_handle2 = physics.colliders.get(prox.collider2).unwrap().parent(); let parent_handle2 = physics.colliders.get(prox.collider2).unwrap().parent();
if let Some(graphics) = &mut graphics {
if parent_handle1 != ground_handle && parent_handle1 != sensor_handle { if parent_handle1 != ground_handle && parent_handle1 != sensor_handle {
graphics.set_body_color(parent_handle1, color); graphics.set_body_color(parent_handle1, color);
} }
@@ -86,6 +86,7 @@ pub fn init_world(testbed: &mut Testbed) {
graphics.set_body_color(parent_handle2, color); graphics.set_body_color(parent_handle2, color);
} }
} }
}
}); });
/* /*

5
examples3d/debug_add_remove_collider3.rs
View File

@@ -34,7 +34,7 @@ pub fn init_world(testbed: &mut Testbed) {
let collider = ColliderBuilder::ball(ball_rad).density(100.0).build(); let collider = ColliderBuilder::ball(ball_rad).density(100.0).build();
colliders.insert(collider, ball_handle, &mut bodies); colliders.insert(collider, ball_handle, &mut bodies);
testbed.add_callback(move |window, physics, _, graphics, _| { testbed.add_callback(move |mut window, mut graphics, physics, _, _| {
// Remove then re-add the ground collider. // Remove then re-add the ground collider.
let coll = physics let coll = physics
.colliders .colliders
@@ -43,7 +43,10 @@ pub fn init_world(testbed: &mut Testbed) {
ground_collider_handle = physics ground_collider_handle = physics
.colliders .colliders
.insert(coll, ground_handle, &mut physics.bodies); .insert(coll, ground_handle, &mut physics.bodies);
if let (Some(graphics), Some(window)) = (&mut graphics, &mut window) {
graphics.add_collider(window, ground_collider_handle, &physics.colliders); graphics.add_collider(window, ground_collider_handle, &physics.colliders);
}
}); });
/* /*

10
examples3d/debug_dynamic_collider_add3.rs
View File

@@ -45,7 +45,7 @@ pub fn init_world(testbed: &mut Testbed) {
let mut extra_colliders = Vec::new(); let mut extra_colliders = Vec::new();
let snapped_frame = 51; let snapped_frame = 51;
testbed.add_callback(move |window, physics, _, graphics, _| { testbed.add_callback(move |mut window, mut graphics, physics, _, _| {
step += 1; step += 1;
// Add a bigger ball collider // Add a bigger ball collider
@@ -56,7 +56,11 @@ pub fn init_world(testbed: &mut Testbed) {
physics physics
.colliders .colliders
.insert(collider, ball_handle, &mut physics.bodies); .insert(collider, ball_handle, &mut physics.bodies);
if let (Some(graphics), Some(window)) = (&mut graphics, &mut window) {
graphics.add_collider(window, new_ball_collider_handle, &physics.colliders); graphics.add_collider(window, new_ball_collider_handle, &physics.colliders);
}
extra_colliders.push(new_ball_collider_handle); extra_colliders.push(new_ball_collider_handle);
// Snap the ball velocity or restore it. // Snap the ball velocity or restore it.
@@ -95,7 +99,11 @@ pub fn init_world(testbed: &mut Testbed) {
physics physics
.colliders .colliders
.insert(coll, ground_handle, &mut physics.bodies); .insert(coll, ground_handle, &mut physics.bodies);
if let (Some(graphics), Some(window)) = (&mut graphics, &mut window) {
graphics.add_collider(window, new_ground_collider_handle, &physics.colliders); graphics.add_collider(window, new_ground_collider_handle, &physics.colliders);
}
extra_colliders.push(new_ground_collider_handle); extra_colliders.push(new_ground_collider_handle);
}); });

2
examples3d/debug_rollback3.rs
View File

@@ -44,7 +44,7 @@ pub fn init_world(testbed: &mut Testbed) {
let mut step = 0; let mut step = 0;
let snapped_frame = 51; let snapped_frame = 51;
testbed.add_callback(move |_, physics, _, _, _| { testbed.add_callback(move |_, _, physics, _, _| {
step += 1; step += 1;
// Snap the ball velocity or restore it. // Snap the ball velocity or restore it.

8
examples3d/fountain3.rs
View File

@@ -26,7 +26,7 @@ pub fn init_world(testbed: &mut Testbed) {
let mut k = 0; let mut k = 0;
// Callback that will be executed on the main loop to handle proximities. // Callback that will be executed on the main loop to handle proximities.
testbed.add_callback(move |window, physics, _, graphics, _| { testbed.add_callback(move |mut window, mut graphics, physics, _, _| {
k += 1; k += 1;
let rigid_body = RigidBodyBuilder::new_dynamic() let rigid_body = RigidBodyBuilder::new_dynamic()
.translation(0.0, 10.0, 0.0) .translation(0.0, 10.0, 0.0)
@@ -41,7 +41,10 @@ pub fn init_world(testbed: &mut Testbed) {
physics physics
.colliders .colliders
.insert(collider, handle, &mut physics.bodies); .insert(collider, handle, &mut physics.bodies);
if let (Some(graphics), Some(window)) = (&mut graphics, &mut window) {
graphics.add(window, handle, &physics.bodies, &physics.colliders); graphics.add(window, handle, &physics.bodies, &physics.colliders);
}
if physics.bodies.len() > MAX_NUMBER_OF_BODIES { if physics.bodies.len() > MAX_NUMBER_OF_BODIES {
let mut to_remove: Vec<_> = physics let mut to_remove: Vec<_> = physics
@@ -67,9 +70,12 @@ pub fn init_world(testbed: &mut Testbed) {
physics physics
.narrow_phase .narrow_phase
.maintain(&mut physics.colliders, &mut physics.bodies); .maintain(&mut physics.colliders, &mut physics.bodies);
if let (Some(graphics), Some(window)) = (&mut graphics, &mut window) {
graphics.remove_body_nodes(window, *handle); graphics.remove_body_nodes(window, *handle);
} }
} }
}
}); });
/* /*

6
examples3d/platform3.rs
View File

@@ -65,7 +65,7 @@ pub fn init_world(testbed: &mut Testbed) {
* Setup a callback to control the platform. * Setup a callback to control the platform.
*/ */
let mut count = 0; let mut count = 0;
testbed.add_callback(move |_, physics, _, _, time| { testbed.add_callback(move |_, _, physics, _, run_state| {
count += 1; count += 1;
if count % 100 > 50 { if count % 100 > 50 {
return; return;
@@ -75,8 +75,8 @@ pub fn init_world(testbed: &mut Testbed) {
let mut next_pos = *platform.position(); let mut next_pos = *platform.position();
let dt = 0.016; let dt = 0.016;
next_pos.translation.vector.y += (time * 5.0).sin() * dt; next_pos.translation.vector.y += (run_state.time * 5.0).sin() * dt;
next_pos.translation.vector.z += time.sin() * 5.0 * dt; next_pos.translation.vector.z += run_state.time.sin() * 5.0 * dt;
if next_pos.translation.vector.z >= rad * 10.0 { if next_pos.translation.vector.z >= rad * 10.0 {
next_pos.translation.vector.z -= dt; next_pos.translation.vector.z -= dt;

4
examples3d/sensor3.rs
View File

@@ -73,7 +73,7 @@ pub fn init_world(testbed: &mut Testbed) {
testbed.set_body_color(sensor_handle, Point3::new(0.5, 1.0, 1.0)); testbed.set_body_color(sensor_handle, Point3::new(0.5, 1.0, 1.0));
// Callback that will be executed on the main loop to handle proximities. // Callback that will be executed on the main loop to handle proximities.
testbed.add_callback(move |_, physics, events, graphics, _| { testbed.add_callback(move |_, mut graphics, physics, events, _| {
while let Ok(prox) = events.proximity_events.try_recv() { while let Ok(prox) = events.proximity_events.try_recv() {
let color = match prox.new_status { let color = match prox.new_status {
Proximity::WithinMargin | Proximity::Intersecting => Point3::new(1.0, 1.0, 0.0), Proximity::WithinMargin | Proximity::Intersecting => Point3::new(1.0, 1.0, 0.0),
@@ -83,6 +83,7 @@ pub fn init_world(testbed: &mut Testbed) {
let parent_handle1 = physics.colliders.get(prox.collider1).unwrap().parent(); let parent_handle1 = physics.colliders.get(prox.collider1).unwrap().parent();
let parent_handle2 = physics.colliders.get(prox.collider2).unwrap().parent(); let parent_handle2 = physics.colliders.get(prox.collider2).unwrap().parent();
if let Some(graphics) = &mut graphics {
if parent_handle1 != ground_handle && parent_handle1 != sensor_handle { if parent_handle1 != ground_handle && parent_handle1 != sensor_handle {
graphics.set_body_color(parent_handle1, color); graphics.set_body_color(parent_handle1, color);
} }
@@ -90,6 +91,7 @@ pub fn init_world(testbed: &mut Testbed) {
graphics.set_body_color(parent_handle2, color); graphics.set_body_color(parent_handle2, color);
} }
} }
}
}); });
/* /*

102
src_testbed/harness/mod.rs
View File

@@ -1,4 +1,8 @@
use crate::physics::{PhysicsEvents, PhysicsState}; use crate::{
physics::{PhysicsEvents, PhysicsState},
GraphicsManager,
};
use kiss3d::window::Window;
use plugin::HarnessPlugin; use plugin::HarnessPlugin;
use rapier::dynamics::{IntegrationParameters, JointSet, RigidBodySet}; use rapier::dynamics::{IntegrationParameters, JointSet, RigidBodySet};
use rapier::geometry::{BroadPhase, ColliderSet, NarrowPhase}; use rapier::geometry::{BroadPhase, ColliderSet, NarrowPhase};
@@ -7,24 +11,58 @@ use rapier::pipeline::{ChannelEventCollector, PhysicsPipeline, QueryPipeline};
pub mod plugin; pub mod plugin;
pub struct HarnessState { pub struct RunState {
#[cfg(feature = "parallel")] #[cfg(feature = "parallel")]
pub thread_pool: rapier::rayon::ThreadPool, pub thread_pool: rapier::rayon::ThreadPool,
#[cfg(feature = "parallel")]
pub num_threads: usize,
pub timestep_id: usize, pub timestep_id: usize,
pub time: f32,
}
impl RunState {
pub fn new() -> Self {
#[cfg(feature = "parallel")]
let num_threads = num_cpus::get_physical();
#[cfg(feature = "parallel")]
let thread_pool = rapier::rayon::ThreadPoolBuilder::new()
.num_threads(num_threads)
.build()
.unwrap();
Self {
#[cfg(feature = "parallel")]
thread_pool: thread_pool,
#[cfg(feature = "parallel")]
num_threads,
timestep_id: 0,
time: 0.0,
}
}
} }
pub struct Harness { pub struct Harness {
physics: PhysicsState, pub physics: PhysicsState,
max_steps: usize, max_steps: usize,
callbacks: Callbacks, callbacks: Callbacks,
plugins: Vec<Box<dyn HarnessPlugin>>, plugins: Vec<Box<dyn HarnessPlugin>>,
time: f32,
events: PhysicsEvents, events: PhysicsEvents,
event_handler: ChannelEventCollector, event_handler: ChannelEventCollector,
pub state: HarnessState, pub state: RunState,
} }
type Callbacks = Vec<Box<dyn FnMut(&mut PhysicsState, &PhysicsEvents, &HarnessState, f32)>>; type Callbacks = Vec<
Box<
dyn FnMut(
Option<&mut Window>,
Option<&mut GraphicsManager>,
&mut PhysicsState,
&PhysicsEvents,
&RunState,
),
>,
>;
#[allow(dead_code)] #[allow(dead_code)]
impl Harness { impl Harness {
@@ -46,18 +84,13 @@ impl Harness {
proximity_events: proximity_channel.1, proximity_events: proximity_channel.1,
}; };
let physics = PhysicsState::new(); let physics = PhysicsState::new();
let state = HarnessState { let state = RunState::new();
#[cfg(feature = "parallel")]
thread_pool,
timestep_id: 0,
};
Self { Self {
physics, physics,
max_steps: 1000, max_steps: 1000,
callbacks: Vec::new(), callbacks: Vec::new(),
plugins: Vec::new(), plugins: Vec::new(),
time: 0.0,
events, events,
event_handler, event_handler,
state, state,
@@ -101,7 +134,6 @@ impl Harness {
self.physics.joints = joints; self.physics.joints = joints;
self.physics.broad_phase = BroadPhase::new(); self.physics.broad_phase = BroadPhase::new();
self.physics.narrow_phase = NarrowPhase::new(); self.physics.narrow_phase = NarrowPhase::new();
self.time = 0.0;
self.state.timestep_id = 0; self.state.timestep_id = 0;
self.physics.query_pipeline = QueryPipeline::new(); self.physics.query_pipeline = QueryPipeline::new();
self.physics.pipeline = PhysicsPipeline::new(); self.physics.pipeline = PhysicsPipeline::new();
@@ -113,7 +145,13 @@ impl Harness {
} }
pub fn add_callback< pub fn add_callback<
F: FnMut(&mut PhysicsState, &PhysicsEvents, &HarnessState, f32) + 'static, F: FnMut(
Option<&mut Window>,
Option<&mut GraphicsManager>,
&mut PhysicsState,
&PhysicsEvents,
&RunState,
) + 'static,
>( >(
&mut self, &mut self,
callback: F, callback: F,
@@ -122,6 +160,14 @@ impl Harness {
} }
pub fn step(&mut self) { pub fn step(&mut self) {
self.step_with_graphics(None, None);
}
pub fn step_with_graphics(
&mut self,
window: Option<&mut Window>,
graphics: Option<&mut GraphicsManager>,
) {
#[cfg(feature = "parallel")] #[cfg(feature = "parallel")]
{ {
let physics = &mut self.physics; let physics = &mut self.physics;
@@ -161,26 +207,44 @@ impl Harness {
.update(&self.physics.bodies, &self.physics.colliders); .update(&self.physics.bodies, &self.physics.colliders);
for plugin in &mut self.plugins { for plugin in &mut self.plugins {
plugin.step(&mut self.physics) plugin.step(&mut self.physics, &self.state)
} }
// FIXME: This assumes either window & graphics are Some, or they are all None
// this is required as we cannot pass Option<&mut Window> & Option<&mut GraphicsManager directly in a loop
// there must be a better way of doing this?
match (window, graphics) {
(Some(window), Some(graphics)) => {
for f in &mut self.callbacks { for f in &mut self.callbacks {
f(&mut self.physics, &self.events, &self.state, self.time) f(
Some(window),
Some(graphics),
&mut self.physics,
&self.events,
&self.state,
);
}
}
_ => {
for f in &mut self.callbacks {
f(None, None, &mut self.physics, &self.events, &self.state);
}
}
} }
for plugin in &mut self.plugins { for plugin in &mut self.plugins {
plugin.run_callbacks(&mut self.physics, &self.events, &self.state, self.time) plugin.run_callbacks(&mut self.physics, &self.events, &self.state)
} }
self.events.poll_all(); self.events.poll_all();
self.time += self.physics.integration_parameters.dt(); self.state.time += self.physics.integration_parameters.dt();
self.state.timestep_id += 1;
} }
pub fn run(&mut self) { pub fn run(&mut self) {
for _ in 0..self.max_steps { for _ in 0..self.max_steps {
self.step(); self.step();
self.state.timestep_id += 1;
} }
} }
} }

7
src_testbed/harness/plugin.rs
View File

@@ -1,4 +1,4 @@
use crate::harness::HarnessState; use crate::harness::RunState;
use crate::physics::PhysicsEvents; use crate::physics::PhysicsEvents;
use crate::PhysicsState; use crate::PhysicsState;
@@ -7,9 +7,8 @@ pub trait HarnessPlugin {
&mut self, &mut self,
physics: &mut PhysicsState, physics: &mut PhysicsState,
events: &PhysicsEvents, events: &PhysicsEvents,
harness_state: &HarnessState, harness_state: &RunState,
t: f32,
); );
fn step(&mut self, physics: &mut PhysicsState); fn step(&mut self, physics: &mut PhysicsState, run_state: &RunState);
fn profiling_string(&self) -> String; fn profiling_string(&self) -> String;
} }

8
src_testbed/plugin.rs
View File

@@ -1,3 +1,4 @@
use crate::harness::RunState;
use crate::physics::PhysicsState; use crate::physics::PhysicsState;
use kiss3d::window::Window; use kiss3d::window::Window;
use na::Point3; use na::Point3;
@@ -5,7 +6,12 @@ use na::Point3;
pub trait TestbedPlugin { pub trait TestbedPlugin {
fn init_graphics(&mut self, window: &mut Window, gen_color: &mut dyn FnMut() -> Point3<f32>); fn init_graphics(&mut self, window: &mut Window, gen_color: &mut dyn FnMut() -> Point3<f32>);
fn clear_graphics(&mut self, window: &mut Window); fn clear_graphics(&mut self, window: &mut Window);
fn run_callbacks(&mut self, window: &mut Window, physics: &mut PhysicsState, t: f32); fn run_callbacks(
&mut self,
window: &mut Window,
physics: &mut PhysicsState,
run_state: &RunState,
);
fn step(&mut self, physics: &mut PhysicsState); fn step(&mut self, physics: &mut PhysicsState);
fn draw(&mut self); fn draw(&mut self);
fn profiling_string(&self) -> String; fn profiling_string(&self) -> String;

377
src_testbed/testbed.rs
View File

@@ -3,10 +3,10 @@ use std::mem;
use std::path::Path; use std::path::Path;
use std::rc::Rc; use std::rc::Rc;
use crate::engine::GraphicsManager;
use crate::physics::{PhysicsEvents, PhysicsSnapshot, PhysicsState}; use crate::physics::{PhysicsEvents, PhysicsSnapshot, PhysicsState};
use crate::plugin::TestbedPlugin; use crate::plugin::TestbedPlugin;
use crate::ui::TestbedUi; use crate::ui::TestbedUi;
use crate::{engine::GraphicsManager, harness::RunState};
use kiss3d::camera::Camera; use kiss3d::camera::Camera;
use kiss3d::event::Event; use kiss3d::event::Event;
@@ -21,14 +21,14 @@ use na::{self, Point2, Point3, Vector3};
use rapier::dynamics::{ use rapier::dynamics::{
ActivationStatus, IntegrationParameters, JointSet, RigidBodyHandle, RigidBodySet, ActivationStatus, IntegrationParameters, JointSet, RigidBodyHandle, RigidBodySet,
}; };
use rapier::geometry::{BroadPhase, ColliderHandle, ColliderSet, NarrowPhase}; use rapier::geometry::{ColliderHandle, ColliderSet, NarrowPhase};
#[cfg(feature = "dim3")] #[cfg(feature = "dim3")]
use rapier::geometry::{InteractionGroups, Ray}; use rapier::geometry::{InteractionGroups, Ray};
use rapier::math::Vector; use rapier::math::Vector;
use rapier::pipeline::{ChannelEventCollector, PhysicsPipeline, QueryPipeline};
#[cfg(all(feature = "dim2", feature = "other-backends"))] #[cfg(all(feature = "dim2", feature = "other-backends"))]
use crate::box2d_backend::Box2dWorld; use crate::box2d_backend::Box2dWorld;
use crate::harness::Harness;
#[cfg(feature = "other-backends")] #[cfg(feature = "other-backends")]
use crate::nphysics_backend::NPhysicsWorld; use crate::nphysics_backend::NPhysicsWorld;
#[cfg(all(feature = "dim3", feature = "other-backends"))] #[cfg(all(feature = "dim3", feature = "other-backends"))]
@@ -114,30 +114,22 @@ pub struct TestbedState {
pub selected_example: usize, pub selected_example: usize,
pub selected_backend: usize, pub selected_backend: usize,
pub physx_use_two_friction_directions: bool, pub physx_use_two_friction_directions: bool,
pub num_threads: usize,
pub snapshot: Option<PhysicsSnapshot>, pub snapshot: Option<PhysicsSnapshot>,
#[cfg(feature = "parallel")]
pub thread_pool: rapier::rayon::ThreadPool,
pub timestep_id: usize,
} }
pub struct Testbed { pub struct Testbed {
builders: Vec<(&'static str, fn(&mut Testbed))>, builders: Vec<(&'static str, fn(&mut Testbed))>,
physics: PhysicsState,
graphics: GraphicsManager, graphics: GraphicsManager,
nsteps: usize, nsteps: usize,
camera_locked: bool, // Used so that the camera can remain the same before and after we change backend or press the restart button. camera_locked: bool, // Used so that the camera can remain the same before and after we change backend or press the restart button.
callbacks: Callbacks,
plugins: Vec<Box<dyn TestbedPlugin>>, plugins: Vec<Box<dyn TestbedPlugin>>,
time: f32,
hide_counters: bool, hide_counters: bool,
// persistant_contacts: HashMap<ContactId, bool>, // persistant_contacts: HashMap<ContactId, bool>,
font: Rc<Font>, font: Rc<Font>,
cursor_pos: Point2<f32>, cursor_pos: Point2<f32>,
events: PhysicsEvents,
event_handler: ChannelEventCollector,
ui: Option<TestbedUi>, ui: Option<TestbedUi>,
state: TestbedState, state: TestbedState,
harness: Harness,
#[cfg(all(feature = "dim2", feature = "other-backends"))] #[cfg(all(feature = "dim2", feature = "other-backends"))]
box2d: Option<Box2dWorld>, box2d: Option<Box2dWorld>,
#[cfg(all(feature = "dim3", feature = "other-backends"))] #[cfg(all(feature = "dim3", feature = "other-backends"))]
@@ -146,9 +138,6 @@ pub struct Testbed {
nphysics: Option<NPhysicsWorld>, nphysics: Option<NPhysicsWorld>,
} }
type Callbacks =
Vec<Box<dyn FnMut(&mut Window, &mut PhysicsState, &PhysicsEvents, &mut GraphicsManager, f32)>>;
impl Testbed { impl Testbed {
pub fn new_empty() -> Testbed { pub fn new_empty() -> Testbed {
let graphics = GraphicsManager::new(); let graphics = GraphicsManager::new();
@@ -166,17 +155,6 @@ impl Testbed {
#[cfg(all(feature = "dim3", feature = "other-backends"))] #[cfg(all(feature = "dim3", feature = "other-backends"))]
backend_names.push("physx (two friction dir)"); backend_names.push("physx (two friction dir)");
#[cfg(feature = "parallel")]
let num_threads = num_cpus::get_physical();
#[cfg(not(feature = "parallel"))]
let num_threads = 1;
#[cfg(feature = "parallel")]
let thread_pool = rapier::rayon::ThreadPoolBuilder::new()
.num_threads(num_threads)
.build()
.unwrap();
let state = TestbedState { let state = TestbedState {
running: RunMode::Running, running: RunMode::Running,
draw_colls: false, draw_colls: false,
@@ -193,40 +171,25 @@ impl Testbed {
backend_names, backend_names,
example_names: Vec::new(), example_names: Vec::new(),
selected_example: 0, selected_example: 0,
timestep_id: 0,
selected_backend: RAPIER_BACKEND, selected_backend: RAPIER_BACKEND,
physx_use_two_friction_directions: true, physx_use_two_friction_directions: true,
num_threads,
#[cfg(feature = "parallel")]
thread_pool,
}; };
let contact_channel = crossbeam::channel::unbounded(); let harness = Harness::new_empty();
let proximity_channel = crossbeam::channel::unbounded();
let event_handler = ChannelEventCollector::new(proximity_channel.0, contact_channel.0);
let events = PhysicsEvents {
contact_events: contact_channel.1,
proximity_events: proximity_channel.1,
};
let physics = PhysicsState::new();
Testbed { Testbed {
builders: Vec::new(), builders: Vec::new(),
physics,
callbacks: Vec::new(),
plugins: Vec::new(), plugins: Vec::new(),
graphics, graphics,
nsteps: 1, nsteps: 1,
camera_locked: false, camera_locked: false,
time: 0.0,
hide_counters: true, hide_counters: true,
// persistant_contacts: HashMap::new(), // persistant_contacts: HashMap::new(),
font: Font::default(), font: Font::default(),
cursor_pos: Point2::new(0.0f32, 0.0), cursor_pos: Point2::new(0.0f32, 0.0),
ui, ui,
event_handler,
events,
state, state,
harness,
#[cfg(all(feature = "dim2", feature = "other-backends"))] #[cfg(all(feature = "dim2", feature = "other-backends"))]
box2d: None, box2d: None,
#[cfg(all(feature = "dim3", feature = "other-backends"))] #[cfg(all(feature = "dim3", feature = "other-backends"))]
@@ -238,7 +201,7 @@ impl Testbed {
pub fn new(bodies: RigidBodySet, colliders: ColliderSet, joints: JointSet) -> Self { pub fn new(bodies: RigidBodySet, colliders: ColliderSet, joints: JointSet) -> Self {
let mut res = Self::new_empty(); let mut res = Self::new_empty();
res.set_world(bodies, colliders, joints); res.harness.set_world(bodies, colliders, joints);
res res
} }
@@ -269,11 +232,15 @@ impl Testbed {
} }
pub fn integration_parameters_mut(&mut self) -> &mut IntegrationParameters { pub fn integration_parameters_mut(&mut self) -> &mut IntegrationParameters {
&mut self.physics.integration_parameters &mut self.harness.physics.integration_parameters
} }
pub fn physics_state_mut(&mut self) -> &mut PhysicsState { pub fn physics_state_mut(&mut self) -> &mut PhysicsState {
&mut self.physics &mut self.harness.physics
}
pub fn harness_mut(&mut self) -> &mut Harness {
&mut self.harness
} }
pub fn set_world(&mut self, bodies: RigidBodySet, colliders: ColliderSet, joints: JointSet) { pub fn set_world(&mut self, bodies: RigidBodySet, colliders: ColliderSet, joints: JointSet) {
@@ -289,30 +256,23 @@ impl Testbed {
) { ) {
println!("Num bodies: {}", bodies.len()); println!("Num bodies: {}", bodies.len());
println!("Num joints: {}", joints.len()); println!("Num joints: {}", joints.len());
self.physics.gravity = gravity; self.harness
self.physics.bodies = bodies; .set_world_with_gravity(bodies, colliders, joints, gravity);
self.physics.colliders = colliders;
self.physics.joints = joints;
self.physics.broad_phase = BroadPhase::new();
self.physics.narrow_phase = NarrowPhase::new();
self.state self.state
.action_flags .action_flags
.set(TestbedActionFlags::RESET_WORLD_GRAPHICS, true); .set(TestbedActionFlags::RESET_WORLD_GRAPHICS, true);
self.time = 0.0;
self.state.timestep_id = 0;
self.state.highlighted_body = None; self.state.highlighted_body = None;
self.physics.query_pipeline = QueryPipeline::new();
self.physics.pipeline = PhysicsPipeline::new();
self.physics.pipeline.counters.enable();
#[cfg(all(feature = "dim2", feature = "other-backends"))] #[cfg(all(feature = "dim2", feature = "other-backends"))]
{ {
if self.state.selected_backend == BOX2D_BACKEND { if self.state.selected_backend == BOX2D_BACKEND {
self.box2d = Some(Box2dWorld::from_rapier( self.box2d = Some(Box2dWorld::from_rapier(
self.physics.gravity, physics.gravity,
&self.physics.bodies, &physics.bodies,
&self.physics.colliders, &physics.colliders,
&self.physics.joints, &physics.joints,
)); ));
} }
} }
@@ -323,13 +283,13 @@ impl Testbed {
|| self.state.selected_backend == PHYSX_BACKEND_TWO_FRICTION_DIR || self.state.selected_backend == PHYSX_BACKEND_TWO_FRICTION_DIR
{ {
self.physx = Some(PhysxWorld::from_rapier( self.physx = Some(PhysxWorld::from_rapier(
self.physics.gravity, physics.gravity,
&self.physics.integration_parameters, &physics.integration_parameters,
&self.physics.bodies, &physics.bodies,
&self.physics.colliders, &physics.colliders,
&self.physics.joints, &physics.joints,
self.state.selected_backend == PHYSX_BACKEND_TWO_FRICTION_DIR, self.state.selected_backend == PHYSX_BACKEND_TWO_FRICTION_DIR,
self.state.num_threads, self.harness.state.num_threads,
)); ));
} }
} }
@@ -338,10 +298,10 @@ impl Testbed {
{ {
if self.state.selected_backend == NPHYSICS_BACKEND { if self.state.selected_backend == NPHYSICS_BACKEND {
self.nphysics = Some(NPhysicsWorld::from_rapier( self.nphysics = Some(NPhysicsWorld::from_rapier(
self.physics.gravity, physics.gravity,
&self.physics.bodies, &physics.bodies,
&self.physics.colliders, &physics.colliders,
&self.physics.joints, &physics.joints,
)); ));
} }
} }
@@ -419,7 +379,6 @@ impl Testbed {
} }
fn clear(&mut self, window: &mut Window) { fn clear(&mut self, window: &mut Window) {
self.callbacks.clear();
// self.persistant_contacts.clear(); // self.persistant_contacts.clear();
// self.state.grabbed_object = None; // self.state.grabbed_object = None;
// self.state.grabbed_object_constraint = None; // self.state.grabbed_object_constraint = None;
@@ -433,17 +392,23 @@ impl Testbed {
self.plugins.clear(); self.plugins.clear();
} }
pub fn add_plugin(&mut self, plugin: impl TestbedPlugin + 'static) {
self.plugins.push(Box::new(plugin));
}
pub fn add_callback< pub fn add_callback<
F: FnMut(&mut Window, &mut PhysicsState, &PhysicsEvents, &mut GraphicsManager, f32) + 'static, F: FnMut(
Option<&mut Window>,
Option<&mut GraphicsManager>,
&mut PhysicsState,
&PhysicsEvents,
&RunState,
) + 'static,
>( >(
&mut self, &mut self,
callback: F, callback: F,
) { ) {
self.callbacks.push(Box::new(callback)); self.harness.add_callback(callback);
}
pub fn add_plugin(&mut self, plugin: impl TestbedPlugin + 'static) {
self.plugins.push(Box::new(plugin));
} }
pub fn run(mut self) { pub fn run(mut self) {
@@ -464,6 +429,7 @@ impl Testbed {
} }
} }
// TODO: move this to dedicated benchmarking code
if benchmark_mode { if benchmark_mode {
use std::fs::File; use std::fs::File;
use std::io::{BufWriter, Write}; use std::io::{BufWriter, Write};
@@ -484,11 +450,23 @@ impl Testbed {
&& (backend_id == PHYSX_BACKEND_PATCH_FRICTION && (backend_id == PHYSX_BACKEND_PATCH_FRICTION
|| backend_id == PHYSX_BACKEND_TWO_FRICTION_DIR) || backend_id == PHYSX_BACKEND_TWO_FRICTION_DIR)
{ {
self.physics.integration_parameters.max_velocity_iterations = 1; self.harness
self.physics.integration_parameters.max_position_iterations = 4; .physics
.integration_parameters
.max_velocity_iterations = 1;
self.harness
.physics
.integration_parameters
.max_position_iterations = 4;
} else { } else {
self.physics.integration_parameters.max_velocity_iterations = 4; self.harness
self.physics.integration_parameters.max_position_iterations = 1; .physics
.integration_parameters
.max_velocity_iterations = 4;
self.harness
.physics
.integration_parameters
.max_position_iterations = 1;
} }
// Init world. // Init world.
(builder.1)(&mut self); (builder.1)(&mut self);
@@ -496,57 +474,20 @@ impl Testbed {
let mut timings = Vec::new(); let mut timings = Vec::new();
for k in 0..=NUM_ITERS { for k in 0..=NUM_ITERS {
{ {
// FIXME: code duplicated from self.step()
if self.state.selected_backend == RAPIER_BACKEND { if self.state.selected_backend == RAPIER_BACKEND {
#[cfg(feature = "parallel")] self.harness.step();
{
let physics = &mut self.physics;
let event_handler = &self.event_handler;
self.state.thread_pool.install(|| {
physics.pipeline.step(
&physics.gravity,
&physics.integration_parameters,
&mut physics.broad_phase,
&mut physics.narrow_phase,
&mut physics.bodies,
&mut physics.colliders,
&mut physics.joints,
None,
None,
event_handler,
);
});
}
#[cfg(not(feature = "parallel"))]
self.physics.pipeline.step(
&self.physics.gravity,
&self.physics.integration_parameters,
&mut self.physics.broad_phase,
&mut self.physics.narrow_phase,
&mut self.physics.bodies,
&mut self.physics.colliders,
&mut self.physics.joints,
None,
None,
&self.event_handler,
);
self.physics
.query_pipeline
.update(&self.physics.bodies, &self.physics.colliders);
} }
#[cfg(all(feature = "dim2", feature = "other-backends"))] #[cfg(all(feature = "dim2", feature = "other-backends"))]
{ {
if self.state.selected_backend == BOX2D_BACKEND { if self.state.selected_backend == BOX2D_BACKEND {
self.box2d.as_mut().unwrap().step( self.box2d.as_mut().unwrap().step(
&mut self.physics.pipeline.counters, &mut self.harness.physics.pipeline.counters,
&self.physics.integration_parameters, &physics.integration_parameters,
); );
self.box2d.as_mut().unwrap().sync( self.box2d.as_mut().unwrap().sync(
&mut self.physics.bodies, &mut self.harness.physics.bodies,
&mut self.physics.colliders, &mut self.harness.physics.colliders,
); );
} }
} }
@@ -558,12 +499,12 @@ impl Testbed {
{ {
// println!("Step"); // println!("Step");
self.physx.as_mut().unwrap().step( self.physx.as_mut().unwrap().step(
&mut self.physics.pipeline.counters, &mut self.harness.physics.pipeline.counters,
&self.physics.integration_parameters, &physics.integration_parameters,
); );
self.physx.as_mut().unwrap().sync( self.physx.as_mut().unwrap().sync(
&mut self.physics.bodies, &mut self.harness.physics.bodies,
&mut self.physics.colliders, &mut self.harness.physics.colliders,
); );
} }
} }
@@ -572,12 +513,12 @@ impl Testbed {
{ {
if self.state.selected_backend == NPHYSICS_BACKEND { if self.state.selected_backend == NPHYSICS_BACKEND {
self.nphysics.as_mut().unwrap().step( self.nphysics.as_mut().unwrap().step(
&mut self.physics.pipeline.counters, &mut self.harness.physics.pipeline.counters,
&self.physics.integration_parameters, &physics.integration_parameters,
); );
self.nphysics.as_mut().unwrap().sync( self.nphysics.as_mut().unwrap().sync(
&mut self.physics.bodies, &mut self.harness.physics.bodies,
&mut self.physics.colliders, &mut self.harness.physics.colliders,
); );
} }
} }
@@ -585,7 +526,7 @@ impl Testbed {
// Skip the first update. // Skip the first update.
if k > 0 { if k > 0 {
timings.push(self.physics.pipeline.counters.step_time.time()); timings.push(self.harness.physics.pipeline.counters.step_time.time());
} }
} }
results.push(timings); results.push(timings);
@@ -640,6 +581,7 @@ impl Testbed {
WindowEvent::Key(Key::C, Action::Release, _) => { WindowEvent::Key(Key::C, Action::Release, _) => {
// Delete 1 collider of 10% of the remaining dynamic bodies. // Delete 1 collider of 10% of the remaining dynamic bodies.
let mut colliders: Vec<_> = self let mut colliders: Vec<_> = self
.harness
.physics .physics
.bodies .bodies
.iter() .iter()
@@ -651,14 +593,17 @@ impl Testbed {
let num_to_delete = (colliders.len() / 10).max(1); let num_to_delete = (colliders.len() / 10).max(1);
for to_delete in &colliders[..num_to_delete] { for to_delete in &colliders[..num_to_delete] {
self.physics self.harness.physics.colliders.remove(
.colliders to_delete[0],
.remove(to_delete[0], &mut self.physics.bodies, true); &mut self.harness.physics.bodies,
true,
);
} }
} }
WindowEvent::Key(Key::D, Action::Release, _) => { WindowEvent::Key(Key::D, Action::Release, _) => {
// Delete 10% of the remaining dynamic bodies. // Delete 10% of the remaining dynamic bodies.
let dynamic_bodies: Vec<_> = self let dynamic_bodies: Vec<_> = self
.harness
.physics .physics
.bodies .bodies
.iter() .iter()
@@ -667,21 +612,23 @@ impl Testbed {
.collect(); .collect();
let num_to_delete = (dynamic_bodies.len() / 10).max(1); let num_to_delete = (dynamic_bodies.len() / 10).max(1);
for to_delete in &dynamic_bodies[..num_to_delete] { for to_delete in &dynamic_bodies[..num_to_delete] {
self.physics.bodies.remove( self.harness.physics.bodies.remove(
*to_delete, *to_delete,
&mut self.physics.colliders, &mut self.harness.physics.colliders,
&mut self.physics.joints, &mut self.harness.physics.joints,
); );
} }
} }
WindowEvent::Key(Key::J, Action::Release, _) => { WindowEvent::Key(Key::J, Action::Release, _) => {
// Delete 10% of the remaining joints. // Delete 10% of the remaining joints.
let joints: Vec<_> = self.physics.joints.iter().map(|e| e.0).collect(); let joints: Vec<_> = self.harness.physics.joints.iter().map(|e| e.0).collect();
let num_to_delete = (joints.len() / 10).max(1); let num_to_delete = (joints.len() / 10).max(1);
for to_delete in &joints[..num_to_delete] { for to_delete in &joints[..num_to_delete] {
self.physics self.harness.physics.joints.remove(
.joints *to_delete,
.remove(*to_delete, &mut self.physics.bodies, true); &mut self.harness.physics.bodies,
true,
);
} }
} }
WindowEvent::CursorPos(x, y, _) => { WindowEvent::CursorPos(x, y, _) => {
@@ -1028,15 +975,16 @@ impl Testbed {
.camera() .camera()
.unproject(&self.cursor_pos, &na::convert(size)); .unproject(&self.cursor_pos, &na::convert(size));
let ray = Ray::new(pos, dir); let ray = Ray::new(pos, dir);
let hit = self.physics.query_pipeline.cast_ray( let physics = &self.harness.physics;
&self.physics.colliders, let hit = physics.query_pipeline.cast_ray(
&physics.colliders,
&ray, &ray,
f32::MAX, f32::MAX,
InteractionGroups::all(), InteractionGroups::all(),
); );
if let Some((_, collider, _)) = hit { if let Some((_, collider, _)) = hit {
if self.physics.bodies[collider.parent()].is_dynamic() { if physics.bodies[collider.parent()].is_dynamic() {
self.state.highlighted_body = Some(collider.parent()); self.state.highlighted_body = Some(collider.parent());
for node in self.graphics.body_nodes_mut(collider.parent()).unwrap() { for node in self.graphics.body_nodes_mut(collider.parent()).unwrap() {
node.select() node.select()
@@ -1075,8 +1023,9 @@ impl State for Testbed {
if let Some(ui) = &mut self.ui { if let Some(ui) = &mut self.ui {
ui.update( ui.update(
window, window,
&mut self.physics.integration_parameters, &mut self.harness.physics.integration_parameters,
&mut self.state, &mut self.state,
&mut self.harness.state,
); );
} }
@@ -1123,7 +1072,7 @@ impl State for Testbed {
self.clear(window); self.clear(window);
if self.state.selected_example != prev_example { if self.state.selected_example != prev_example {
self.physics.integration_parameters = IntegrationParameters::default(); self.harness.physics.integration_parameters = IntegrationParameters::default();
} }
self.builders[self.state.selected_example].1(self); self.builders[self.state.selected_example].1(self);
@@ -1140,12 +1089,12 @@ impl State for Testbed {
.action_flags .action_flags
.set(TestbedActionFlags::TAKE_SNAPSHOT, false); .set(TestbedActionFlags::TAKE_SNAPSHOT, false);
self.state.snapshot = PhysicsSnapshot::new( self.state.snapshot = PhysicsSnapshot::new(
self.state.timestep_id, self.harness.state.timestep_id,
&self.physics.broad_phase, &self.harness.physics.broad_phase,
&self.physics.narrow_phase, &self.harness.physics.narrow_phase,
&self.physics.bodies, &self.harness.physics.bodies,
&self.physics.colliders, &self.harness.physics.colliders,
&self.physics.joints, &self.harness.physics.joints,
) )
.ok(); .ok();
@@ -1172,9 +1121,9 @@ impl State for Testbed {
} }
self.set_world(w.3, w.4, w.5); self.set_world(w.3, w.4, w.5);
self.physics.broad_phase = w.1; self.harness.physics.broad_phase = w.1;
self.physics.narrow_phase = w.2; self.harness.physics.narrow_phase = w.2;
self.state.timestep_id = w.0; self.harness.state.timestep_id = w.0;
} }
} }
} }
@@ -1187,12 +1136,12 @@ impl State for Testbed {
self.state self.state
.action_flags .action_flags
.set(TestbedActionFlags::RESET_WORLD_GRAPHICS, false); .set(TestbedActionFlags::RESET_WORLD_GRAPHICS, false);
for (handle, _) in self.physics.bodies.iter() { for (handle, _) in self.harness.physics.bodies.iter() {
self.graphics.add( self.graphics.add(
window, window,
handle, handle,
&self.physics.bodies, &self.harness.physics.bodies,
&self.physics.colliders, &self.harness.physics.colliders,
); );
} }
@@ -1207,7 +1156,7 @@ impl State for Testbed {
!= self.state.flags.contains(TestbedStateFlags::WIREFRAME) != self.state.flags.contains(TestbedStateFlags::WIREFRAME)
{ {
self.graphics.toggle_wireframe_mode( self.graphics.toggle_wireframe_mode(
&self.physics.colliders, &self.harness.physics.colliders,
self.state.flags.contains(TestbedStateFlags::WIREFRAME), self.state.flags.contains(TestbedStateFlags::WIREFRAME),
) )
} }
@@ -1216,11 +1165,11 @@ impl State for Testbed {
!= self.state.flags.contains(TestbedStateFlags::SLEEP) != self.state.flags.contains(TestbedStateFlags::SLEEP)
{ {
if self.state.flags.contains(TestbedStateFlags::SLEEP) { if self.state.flags.contains(TestbedStateFlags::SLEEP) {
for (_, mut body) in self.physics.bodies.iter_mut() { for (_, mut body) in self.harness.physics.bodies.iter_mut() {
body.activation.threshold = ActivationStatus::default_threshold(); body.activation.threshold = ActivationStatus::default_threshold();
} }
} else { } else {
for (_, mut body) in self.physics.bodies.iter_mut() { for (_, mut body) in self.harness.physics.bodies.iter_mut() {
body.wake_up(true); body.wake_up(true);
body.activation.threshold = -1.0; body.activation.threshold = -1.0;
} }
@@ -1233,7 +1182,10 @@ impl State for Testbed {
.contains(TestbedStateFlags::SUB_STEPPING) .contains(TestbedStateFlags::SUB_STEPPING)
!= self.state.flags.contains(TestbedStateFlags::SUB_STEPPING) != self.state.flags.contains(TestbedStateFlags::SUB_STEPPING)
{ {
self.physics.integration_parameters.return_after_ccd_substep = self.harness
.physics
.integration_parameters
.return_after_ccd_substep =
self.state.flags.contains(TestbedStateFlags::SUB_STEPPING); self.state.flags.contains(TestbedStateFlags::SUB_STEPPING);
} }
@@ -1283,48 +1235,13 @@ impl State for Testbed {
if self.state.running != RunMode::Stop { if self.state.running != RunMode::Stop {
for _ in 0..self.nsteps { for _ in 0..self.nsteps {
self.state.timestep_id += 1;
if self.state.selected_backend == RAPIER_BACKEND { if self.state.selected_backend == RAPIER_BACKEND {
#[cfg(feature = "parallel")] let graphics = &mut self.graphics;
{ self.harness
let physics = &mut self.physics; .step_with_graphics(Some(window), Some(graphics));
let event_handler = &self.event_handler;
self.state.thread_pool.install(|| {
physics.pipeline.step(
&physics.gravity,
&physics.integration_parameters,
&mut physics.broad_phase,
&mut physics.narrow_phase,
&mut physics.bodies,
&mut physics.colliders,
&mut physics.joints,
None,
None,
event_handler,
);
});
}
#[cfg(not(feature = "parallel"))]
self.physics.pipeline.step(
&self.physics.gravity,
&self.physics.integration_parameters,
&mut self.physics.broad_phase,
&mut self.physics.narrow_phase,
&mut self.physics.bodies,
&mut self.physics.colliders,
&mut self.physics.joints,
None,
None,
&self.event_handler,
);
self.physics
.query_pipeline
.update(&self.physics.bodies, &self.physics.colliders);
for plugin in &mut self.plugins { for plugin in &mut self.plugins {
plugin.step(&mut self.physics) plugin.step(&mut self.harness.physics)
} }
} }
@@ -1332,13 +1249,13 @@ impl State for Testbed {
{ {
if self.state.selected_backend == BOX2D_BACKEND { if self.state.selected_backend == BOX2D_BACKEND {
self.box2d.as_mut().unwrap().step( self.box2d.as_mut().unwrap().step(
&mut self.physics.pipeline.counters, &mut physics.pipeline.counters,
&self.physics.integration_parameters, &physics.integration_parameters,
); );
self.box2d self.box2d
.as_mut() .as_mut()
.unwrap() .unwrap()
.sync(&mut self.physics.bodies, &mut self.physics.colliders); .sync(&mut physics.bodies, &mut physics.colliders);
} }
} }
@@ -1349,13 +1266,13 @@ impl State for Testbed {
{ {
// println!("Step"); // println!("Step");
self.physx.as_mut().unwrap().step( self.physx.as_mut().unwrap().step(
&mut self.physics.pipeline.counters, &mut physics.pipeline.counters,
&self.physics.integration_parameters, &physics.integration_parameters,
); );
self.physx self.physx
.as_mut() .as_mut()
.unwrap() .unwrap()
.sync(&mut self.physics.bodies, &mut self.physics.colliders); .sync(&mut physics.bodies, &mut physics.colliders);
} }
} }
@@ -1363,32 +1280,20 @@ impl State for Testbed {
{ {
if self.state.selected_backend == NPHYSICS_BACKEND { if self.state.selected_backend == NPHYSICS_BACKEND {
self.nphysics.as_mut().unwrap().step( self.nphysics.as_mut().unwrap().step(
&mut self.physics.pipeline.counters, &mut physics.pipeline.counters,
&self.physics.integration_parameters, &physics.integration_parameters,
); );
self.nphysics self.nphysics
.as_mut() .as_mut()
.unwrap() .unwrap()
.sync(&mut self.physics.bodies, &mut self.physics.colliders); .sync(&mut physics.bodies, &mut physics.colliders);
} }
} }
for f in &mut self.callbacks {
f(
window,
&mut self.physics,
&self.events,
&mut self.graphics,
self.time,
)
}
for plugin in &mut self.plugins { for plugin in &mut self.plugins {
plugin.run_callbacks(window, &mut self.physics, self.time) plugin.run_callbacks(window, &mut self.harness.physics, &self.harness.state);
} }
self.events.poll_all();
// if true { // if true {
// // !self.hide_counters { // // !self.hide_counters {
// #[cfg(not(feature = "log"))] // #[cfg(not(feature = "log"))]
@@ -1396,20 +1301,21 @@ impl State for Testbed {
// #[cfg(feature = "log")] // #[cfg(feature = "log")]
// debug!("{}", self.world.counters); // debug!("{}", self.world.counters);
// } // }
self.time += self.physics.integration_parameters.dt();
} }
} }
self.highlight_hovered_body(window); self.highlight_hovered_body(window);
let physics = &self.harness.physics;
self.graphics self.graphics
.draw(&self.physics.bodies, &self.physics.colliders, window); .draw(&physics.bodies, &physics.colliders, window);
for plugin in &mut self.plugins { for plugin in &mut self.plugins {
plugin.draw(); plugin.draw();
} }
if self.state.flags.contains(TestbedStateFlags::CONTACT_POINTS) { if self.state.flags.contains(TestbedStateFlags::CONTACT_POINTS) {
draw_contacts(window, &self.physics.narrow_phase, &self.physics.colliders); draw_contacts(window, &physics.narrow_phase, &physics.colliders);
} }
if self.state.running == RunMode::Step { if self.state.running == RunMode::Step {
@@ -1421,7 +1327,7 @@ impl State for Testbed {
} }
let color = Point3::new(0.0, 0.0, 0.0); let color = Point3::new(0.0, 0.0, 0.0);
let counters = self.physics.pipeline.counters; let counters = physics.pipeline.counters;
let mut profile = String::new(); let mut profile = String::new();
if self.state.flags.contains(TestbedStateFlags::PROFILE) { if self.state.flags.contains(TestbedStateFlags::PROFILE) {
@@ -1472,11 +1378,12 @@ CCD: {:.2}ms
if self.state.flags.contains(TestbedStateFlags::DEBUG) { if self.state.flags.contains(TestbedStateFlags::DEBUG) {
let t = instant::now(); let t = instant::now();
let bf = bincode::serialize(&self.physics.broad_phase).unwrap(); let physics = &self.harness.physics;
let nf = bincode::serialize(&self.physics.narrow_phase).unwrap(); let bf = bincode::serialize(&physics.broad_phase).unwrap();
let bs = bincode::serialize(&self.physics.bodies).unwrap(); let nf = bincode::serialize(&physics.narrow_phase).unwrap();
let cs = bincode::serialize(&self.physics.colliders).unwrap(); let bs = bincode::serialize(&physics.bodies).unwrap();
let js = bincode::serialize(&self.physics.joints).unwrap(); let cs = bincode::serialize(&physics.colliders).unwrap();
let js = bincode::serialize(&physics.joints).unwrap();
let serialization_time = instant::now() - t; let serialization_time = instant::now() - t;
let hash_bf = md5::compute(&bf); let hash_bf = md5::compute(&bf);
let hash_nf = md5::compute(&nf); let hash_nf = md5::compute(&nf);
@@ -1494,7 +1401,7 @@ Hashes at frame: {}
|_ Joints [{:.1}KB]: {:?}"#, |_ Joints [{:.1}KB]: {:?}"#,
profile, profile,
serialization_time, serialization_time,
self.state.timestep_id, self.harness.state.timestep_id,
bf.len() as f32 / 1000.0, bf.len() as f32 / 1000.0,
hash_bf, hash_bf,
nf.len() as f32 / 1000.0, nf.len() as f32 / 1000.0,

12
src_testbed/ui.rs
View File

@@ -2,6 +2,7 @@ use kiss3d::conrod::{self, Borderable, Colorable, Labelable, Positionable, Sizea
use kiss3d::window::Window; use kiss3d::window::Window;
use rapier::dynamics::IntegrationParameters; use rapier::dynamics::IntegrationParameters;
use crate::harness::RunState;
use crate::testbed::{RunMode, TestbedActionFlags, TestbedState, TestbedStateFlags}; use crate::testbed::{RunMode, TestbedActionFlags, TestbedState, TestbedStateFlags};
const SIDEBAR_W: f64 = 200.0; const SIDEBAR_W: f64 = 200.0;
@@ -98,6 +99,7 @@ impl TestbedUi {
window: &mut Window, window: &mut Window,
integration_parameters: &mut IntegrationParameters, integration_parameters: &mut IntegrationParameters,
state: &mut TestbedState, state: &mut TestbedState,
run_state: &mut RunState,
) { ) {
let ui_root = window.conrod_ui().window; let ui_root = window.conrod_ui().window;
let mut ui = window.conrod_ui_mut().set_widgets(); let mut ui = window.conrod_ui_mut().set_widgets();
@@ -254,7 +256,7 @@ impl TestbedUi {
let curr_vel_iters = integration_parameters.max_velocity_iterations; let curr_vel_iters = integration_parameters.max_velocity_iterations;
let curr_pos_iters = integration_parameters.max_position_iterations; let curr_pos_iters = integration_parameters.max_position_iterations;
#[cfg(feature = "parallel")] #[cfg(feature = "parallel")]
let curr_num_threads = state.num_threads; let curr_num_threads = run_state.num_threads;
let curr_max_ccd_substeps = integration_parameters.max_ccd_substeps; let curr_max_ccd_substeps = integration_parameters.max_ccd_substeps;
let curr_min_island_size = integration_parameters.min_island_size; let curr_min_island_size = integration_parameters.min_island_size;
let curr_warmstart_coeff = integration_parameters.warmstart_coeff; let curr_warmstart_coeff = integration_parameters.warmstart_coeff;
@@ -305,10 +307,10 @@ impl TestbedUi {
.w_h(ELEMENT_W, ELEMENT_H) .w_h(ELEMENT_W, ELEMENT_H)
.set(self.ids.slider_num_threads, &mut ui) .set(self.ids.slider_num_threads, &mut ui)
{ {
if state.num_threads != val as usize { if run_state.num_threads != val as usize {
state.num_threads = val as usize; run_state.num_threads = val as usize;
state.thread_pool = rapier::rayon::ThreadPoolBuilder::new() run_state.thread_pool = rapier::rayon::ThreadPoolBuilder::new()
.num_threads(state.num_threads) .num_threads(run_state.num_threads)
.build() .build()
.unwrap(); .unwrap();
} }