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;
// 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()
.translation(0.0, 10.0)
.build();
@@ -19,7 +19,10 @@ pub fn init_world(testbed: &mut Testbed) {
physics
.colliders
.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
.bodies
@@ -31,7 +34,10 @@ pub fn init_world(testbed: &mut Testbed) {
physics
.bodies
.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.
*/
testbed.add_callback(move |_, physics, _, _, time| {
testbed.add_callback(move |_, _, physics, _, run_state| {
let platform = physics.bodies.get_mut(platform_handle).unwrap();
let mut next_pos = *platform.position();
let dt = 0.016;
next_pos.translation.vector.y += (time * 5.0).sin() * dt;
next_pos.translation.vector.x += time.sin() * 5.0 * dt;
next_pos.translation.vector.y += (run_state.time * 5.0).sin() * dt;
next_pos.translation.vector.x += run_state.time.sin() * 5.0 * dt;
if next_pos.translation.vector.x >= rad * 10.0 {
next_pos.translation.vector.x -= dt;

15
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));
// 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() {
let color = match prox.new_status {
Proximity::WithinMargin | Proximity::Intersecting => Point3::new(1.0, 1.0, 0.0),
@@ -78,12 +78,13 @@ pub fn init_world(testbed: &mut Testbed) {
let parent_handle1 = physics.colliders.get(prox.collider1).unwrap().parent();
let parent_handle2 = physics.colliders.get(prox.collider2).unwrap().parent();
if parent_handle1 != ground_handle && parent_handle1 != sensor_handle {
graphics.set_body_color(parent_handle1, color);
}
if parent_handle2 != ground_handle && parent_handle2 != sensor_handle {
graphics.set_body_color(parent_handle2, color);
if let Some(graphics) = &mut graphics {
if parent_handle1 != ground_handle && parent_handle1 != sensor_handle {
graphics.set_body_color(parent_handle1, color);
}
if parent_handle2 != ground_handle && parent_handle2 != sensor_handle {
graphics.set_body_color(parent_handle2, color);
}
}
}
});

7
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();
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.
let coll = physics
.colliders
@@ -43,7 +43,10 @@ pub fn init_world(testbed: &mut Testbed) {
ground_collider_handle = physics
.colliders
.insert(coll, ground_handle, &mut physics.bodies);
graphics.add_collider(window, ground_collider_handle, &physics.colliders);
if let (Some(graphics), Some(window)) = (&mut graphics, &mut window) {
graphics.add_collider(window, ground_collider_handle, &physics.colliders);
}
});
/*

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

12
examples3d/fountain3.rs
View File

@@ -26,7 +26,7 @@ pub fn init_world(testbed: &mut Testbed) {
let mut k = 0;
// 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;
let rigid_body = RigidBodyBuilder::new_dynamic()
.translation(0.0, 10.0, 0.0)
@@ -41,7 +41,10 @@ pub fn init_world(testbed: &mut Testbed) {
physics
.colliders
.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);
}
if physics.bodies.len() > MAX_NUMBER_OF_BODIES {
let mut to_remove: Vec<_> = physics
@@ -67,7 +70,10 @@ pub fn init_world(testbed: &mut Testbed) {
physics
.narrow_phase
.maintain(&mut physics.colliders, &mut physics.bodies);
graphics.remove_body_nodes(window, *handle);
if let (Some(graphics), Some(window)) = (&mut graphics, &mut window) {
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.
*/
let mut count = 0;
testbed.add_callback(move |_, physics, _, _, time| {
testbed.add_callback(move |_, _, physics, _, run_state| {
count += 1;
if count % 100 > 50 {
return;
@@ -75,8 +75,8 @@ pub fn init_world(testbed: &mut Testbed) {
let mut next_pos = *platform.position();
let dt = 0.016;
next_pos.translation.vector.y += (time * 5.0).sin() * dt;
next_pos.translation.vector.z += time.sin() * 5.0 * dt;
next_pos.translation.vector.y += (run_state.time * 5.0).sin() * dt;
next_pos.translation.vector.z += run_state.time.sin() * 5.0 * dt;
if next_pos.translation.vector.z >= rad * 10.0 {
next_pos.translation.vector.z -= dt;

14
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));
// 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() {
let color = match prox.new_status {
Proximity::WithinMargin | Proximity::Intersecting => Point3::new(1.0, 1.0, 0.0),
@@ -83,11 +83,13 @@ pub fn init_world(testbed: &mut Testbed) {
let parent_handle1 = physics.colliders.get(prox.collider1).unwrap().parent();
let parent_handle2 = physics.colliders.get(prox.collider2).unwrap().parent();
if parent_handle1 != ground_handle && parent_handle1 != sensor_handle {
graphics.set_body_color(parent_handle1, color);
}
if parent_handle2 != ground_handle && parent_handle2 != sensor_handle {
graphics.set_body_color(parent_handle2, color);
if let Some(graphics) = &mut graphics {
if parent_handle1 != ground_handle && parent_handle1 != sensor_handle {
graphics.set_body_color(parent_handle1, color);
}
if parent_handle2 != ground_handle && parent_handle2 != sensor_handle {
graphics.set_body_color(parent_handle2, color);
}
}
}
});

104
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 rapier::dynamics::{IntegrationParameters, JointSet, RigidBodySet};
use rapier::geometry::{BroadPhase, ColliderSet, NarrowPhase};
@@ -7,24 +11,58 @@ use rapier::pipeline::{ChannelEventCollector, PhysicsPipeline, QueryPipeline};
pub mod plugin;
pub struct HarnessState {
pub struct RunState {
#[cfg(feature = "parallel")]
pub thread_pool: rapier::rayon::ThreadPool,
#[cfg(feature = "parallel")]
pub num_threads: 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 {
physics: PhysicsState,
pub physics: PhysicsState,
max_steps: usize,
callbacks: Callbacks,
plugins: Vec<Box<dyn HarnessPlugin>>,
time: f32,
events: PhysicsEvents,
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)]
impl Harness {
@@ -46,18 +84,13 @@ impl Harness {
proximity_events: proximity_channel.1,
};
let physics = PhysicsState::new();
let state = HarnessState {
#[cfg(feature = "parallel")]
thread_pool,
timestep_id: 0,
};
let state = RunState::new();
Self {
physics,
max_steps: 1000,
callbacks: Vec::new(),
plugins: Vec::new(),
time: 0.0,
events,
event_handler,
state,
@@ -101,7 +134,6 @@ impl Harness {
self.physics.joints = joints;
self.physics.broad_phase = BroadPhase::new();
self.physics.narrow_phase = NarrowPhase::new();
self.time = 0.0;
self.state.timestep_id = 0;
self.physics.query_pipeline = QueryPipeline::new();
self.physics.pipeline = PhysicsPipeline::new();
@@ -113,7 +145,13 @@ impl Harness {
}
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,
callback: F,
@@ -122,6 +160,14 @@ impl Harness {
}
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")]
{
let physics = &mut self.physics;
@@ -161,26 +207,44 @@ impl Harness {
.update(&self.physics.bodies, &self.physics.colliders);
for plugin in &mut self.plugins {
plugin.step(&mut self.physics)
plugin.step(&mut self.physics, &self.state)
}
for f in &mut self.callbacks {
f(&mut self.physics, &self.events, &self.state, self.time)
// 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 {
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 {
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.time += self.physics.integration_parameters.dt();
self.state.time += self.physics.integration_parameters.dt();
self.state.timestep_id += 1;
}
pub fn run(&mut self) {
for _ in 0..self.max_steps {
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::PhysicsState;
@@ -7,9 +7,8 @@ pub trait HarnessPlugin {
&mut self,
physics: &mut PhysicsState,
events: &PhysicsEvents,
harness_state: &HarnessState,
t: f32,
harness_state: &RunState,
);
fn step(&mut self, physics: &mut PhysicsState);
fn step(&mut self, physics: &mut PhysicsState, run_state: &RunState);
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 kiss3d::window::Window;
use na::Point3;
@@ -5,7 +6,12 @@ use na::Point3;
pub trait TestbedPlugin {
fn init_graphics(&mut self, window: &mut Window, gen_color: &mut dyn FnMut() -> Point3<f32>);
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 draw(&mut self);
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::rc::Rc;
use crate::engine::GraphicsManager;
use crate::physics::{PhysicsEvents, PhysicsSnapshot, PhysicsState};
use crate::plugin::TestbedPlugin;
use crate::ui::TestbedUi;
use crate::{engine::GraphicsManager, harness::RunState};
use kiss3d::camera::Camera;
use kiss3d::event::Event;
@@ -21,14 +21,14 @@ use na::{self, Point2, Point3, Vector3};
use rapier::dynamics::{
ActivationStatus, IntegrationParameters, JointSet, RigidBodyHandle, RigidBodySet,
};
use rapier::geometry::{BroadPhase, ColliderHandle, ColliderSet, NarrowPhase};
use rapier::geometry::{ColliderHandle, ColliderSet, NarrowPhase};
#[cfg(feature = "dim3")]
use rapier::geometry::{InteractionGroups, Ray};
use rapier::math::Vector;
use rapier::pipeline::{ChannelEventCollector, PhysicsPipeline, QueryPipeline};
#[cfg(all(feature = "dim2", feature = "other-backends"))]
use crate::box2d_backend::Box2dWorld;
use crate::harness::Harness;
#[cfg(feature = "other-backends")]
use crate::nphysics_backend::NPhysicsWorld;
#[cfg(all(feature = "dim3", feature = "other-backends"))]
@@ -114,30 +114,22 @@ pub struct TestbedState {
pub selected_example: usize,
pub selected_backend: usize,
pub physx_use_two_friction_directions: bool,
pub num_threads: usize,
pub snapshot: Option<PhysicsSnapshot>,
#[cfg(feature = "parallel")]
pub thread_pool: rapier::rayon::ThreadPool,
pub timestep_id: usize,
}
pub struct Testbed {
builders: Vec<(&'static str, fn(&mut Testbed))>,
physics: PhysicsState,
graphics: GraphicsManager,
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.
callbacks: Callbacks,
plugins: Vec<Box<dyn TestbedPlugin>>,
time: f32,
hide_counters: bool,
// persistant_contacts: HashMap<ContactId, bool>,
font: Rc<Font>,
cursor_pos: Point2<f32>,
events: PhysicsEvents,
event_handler: ChannelEventCollector,
ui: Option<TestbedUi>,
state: TestbedState,
harness: Harness,
#[cfg(all(feature = "dim2", feature = "other-backends"))]
box2d: Option<Box2dWorld>,
#[cfg(all(feature = "dim3", feature = "other-backends"))]
@@ -146,9 +138,6 @@ pub struct Testbed {
nphysics: Option<NPhysicsWorld>,
}
type Callbacks =
Vec<Box<dyn FnMut(&mut Window, &mut PhysicsState, &PhysicsEvents, &mut GraphicsManager, f32)>>;
impl Testbed {
pub fn new_empty() -> Testbed {
let graphics = GraphicsManager::new();
@@ -166,17 +155,6 @@ impl Testbed {
#[cfg(all(feature = "dim3", feature = "other-backends"))]
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 {
running: RunMode::Running,
draw_colls: false,
@@ -193,40 +171,25 @@ impl Testbed {
backend_names,
example_names: Vec::new(),
selected_example: 0,
timestep_id: 0,
selected_backend: RAPIER_BACKEND,
physx_use_two_friction_directions: true,
num_threads,
#[cfg(feature = "parallel")]
thread_pool,
};
let contact_channel = crossbeam::channel::unbounded();
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();
let harness = Harness::new_empty();
Testbed {
builders: Vec::new(),
physics,
callbacks: Vec::new(),
plugins: Vec::new(),
graphics,
nsteps: 1,
camera_locked: false,
time: 0.0,
hide_counters: true,
// persistant_contacts: HashMap::new(),
font: Font::default(),
cursor_pos: Point2::new(0.0f32, 0.0),
ui,
event_handler,
events,
state,
harness,
#[cfg(all(feature = "dim2", feature = "other-backends"))]
box2d: None,
#[cfg(all(feature = "dim3", feature = "other-backends"))]
@@ -238,7 +201,7 @@ impl Testbed {
pub fn new(bodies: RigidBodySet, colliders: ColliderSet, joints: JointSet) -> Self {
let mut res = Self::new_empty();
res.set_world(bodies, colliders, joints);
res.harness.set_world(bodies, colliders, joints);
res
}
@@ -269,11 +232,15 @@ impl Testbed {
}
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 {
&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) {
@@ -289,30 +256,23 @@ impl Testbed {
) {
println!("Num bodies: {}", bodies.len());
println!("Num joints: {}", joints.len());
self.physics.gravity = gravity;
self.physics.bodies = bodies;
self.physics.colliders = colliders;
self.physics.joints = joints;
self.physics.broad_phase = BroadPhase::new();
self.physics.narrow_phase = NarrowPhase::new();
self.harness
.set_world_with_gravity(bodies, colliders, joints, gravity);
self.state
.action_flags
.set(TestbedActionFlags::RESET_WORLD_GRAPHICS, true);
self.time = 0.0;
self.state.timestep_id = 0;
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"))]
{
if self.state.selected_backend == BOX2D_BACKEND {
self.box2d = Some(Box2dWorld::from_rapier(
self.physics.gravity,
&self.physics.bodies,
&self.physics.colliders,
&self.physics.joints,
physics.gravity,
&physics.bodies,
&physics.colliders,
&physics.joints,
));
}
}
@@ -323,13 +283,13 @@ impl Testbed {
|| self.state.selected_backend == PHYSX_BACKEND_TWO_FRICTION_DIR
{
self.physx = Some(PhysxWorld::from_rapier(
self.physics.gravity,
&self.physics.integration_parameters,
&self.physics.bodies,
&self.physics.colliders,
&self.physics.joints,
physics.gravity,
&physics.integration_parameters,
&physics.bodies,
&physics.colliders,
&physics.joints,
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 {
self.nphysics = Some(NPhysicsWorld::from_rapier(
self.physics.gravity,
&self.physics.bodies,
&self.physics.colliders,
&self.physics.joints,
physics.gravity,
&physics.bodies,
&physics.colliders,
&physics.joints,
));
}
}
@@ -419,7 +379,6 @@ impl Testbed {
}
fn clear(&mut self, window: &mut Window) {
self.callbacks.clear();
// self.persistant_contacts.clear();
// self.state.grabbed_object = None;
// self.state.grabbed_object_constraint = None;
@@ -433,17 +392,23 @@ impl Testbed {
self.plugins.clear();
}
pub fn add_plugin(&mut self, plugin: impl TestbedPlugin + 'static) {
self.plugins.push(Box::new(plugin));
}
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,
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) {
@@ -464,6 +429,7 @@ impl Testbed {
}
}
// TODO: move this to dedicated benchmarking code
if benchmark_mode {
use std::fs::File;
use std::io::{BufWriter, Write};
@@ -484,11 +450,23 @@ impl Testbed {
&& (backend_id == PHYSX_BACKEND_PATCH_FRICTION
|| backend_id == PHYSX_BACKEND_TWO_FRICTION_DIR)
{
self.physics.integration_parameters.max_velocity_iterations = 1;
self.physics.integration_parameters.max_position_iterations = 4;
self.harness
.physics
.integration_parameters
.max_velocity_iterations = 1;
self.harness
.physics
.integration_parameters
.max_position_iterations = 4;
} else {
self.physics.integration_parameters.max_velocity_iterations = 4;
self.physics.integration_parameters.max_position_iterations = 1;
self.harness
.physics
.integration_parameters
.max_velocity_iterations = 4;
self.harness
.physics
.integration_parameters
.max_position_iterations = 1;
}
// Init world.
(builder.1)(&mut self);
@@ -496,57 +474,20 @@ impl Testbed {
let mut timings = Vec::new();
for k in 0..=NUM_ITERS {
{
// FIXME: code duplicated from self.step()
if self.state.selected_backend == RAPIER_BACKEND {
#[cfg(feature = "parallel")]
{
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);
self.harness.step();
}
#[cfg(all(feature = "dim2", feature = "other-backends"))]
{
if self.state.selected_backend == BOX2D_BACKEND {
self.box2d.as_mut().unwrap().step(
&mut self.physics.pipeline.counters,
&self.physics.integration_parameters,
&mut self.harness.physics.pipeline.counters,
&physics.integration_parameters,
);
self.box2d.as_mut().unwrap().sync(
&mut self.physics.bodies,
&mut self.physics.colliders,
&mut self.harness.physics.bodies,
&mut self.harness.physics.colliders,
);
}
}
@@ -558,12 +499,12 @@ impl Testbed {
{
// println!("Step");
self.physx.as_mut().unwrap().step(
&mut self.physics.pipeline.counters,
&self.physics.integration_parameters,
&mut self.harness.physics.pipeline.counters,
&physics.integration_parameters,
);
self.physx.as_mut().unwrap().sync(
&mut self.physics.bodies,
&mut self.physics.colliders,
&mut self.harness.physics.bodies,
&mut self.harness.physics.colliders,
);
}
}
@@ -572,12 +513,12 @@ impl Testbed {
{
if self.state.selected_backend == NPHYSICS_BACKEND {
self.nphysics.as_mut().unwrap().step(
&mut self.physics.pipeline.counters,
&self.physics.integration_parameters,
&mut self.harness.physics.pipeline.counters,
&physics.integration_parameters,
);
self.nphysics.as_mut().unwrap().sync(
&mut self.physics.bodies,
&mut self.physics.colliders,
&mut self.harness.physics.bodies,
&mut self.harness.physics.colliders,
);
}
}
@@ -585,7 +526,7 @@ impl Testbed {
// Skip the first update.
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);
@@ -640,6 +581,7 @@ impl Testbed {
WindowEvent::Key(Key::C, Action::Release, _) => {
// Delete 1 collider of 10% of the remaining dynamic bodies.
let mut colliders: Vec<_> = self
.harness
.physics
.bodies
.iter()
@@ -651,14 +593,17 @@ impl Testbed {
let num_to_delete = (colliders.len() / 10).max(1);
for to_delete in &colliders[..num_to_delete] {
self.physics
.colliders
.remove(to_delete[0], &mut self.physics.bodies, true);
self.harness.physics.colliders.remove(
to_delete[0],
&mut self.harness.physics.bodies,
true,
);
}
}
WindowEvent::Key(Key::D, Action::Release, _) => {
// Delete 10% of the remaining dynamic bodies.
let dynamic_bodies: Vec<_> = self
.harness
.physics
.bodies
.iter()
@@ -667,21 +612,23 @@ impl Testbed {
.collect();
let num_to_delete = (dynamic_bodies.len() / 10).max(1);
for to_delete in &dynamic_bodies[..num_to_delete] {
self.physics.bodies.remove(
self.harness.physics.bodies.remove(
*to_delete,
&mut self.physics.colliders,
&mut self.physics.joints,
&mut self.harness.physics.colliders,
&mut self.harness.physics.joints,
);
}
}
WindowEvent::Key(Key::J, Action::Release, _) => {
// 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);
for to_delete in &joints[..num_to_delete] {
self.physics
.joints
.remove(*to_delete, &mut self.physics.bodies, true);
self.harness.physics.joints.remove(
*to_delete,
&mut self.harness.physics.bodies,
true,
);
}
}
WindowEvent::CursorPos(x, y, _) => {
@@ -1028,15 +975,16 @@ impl Testbed {
.camera()
.unproject(&self.cursor_pos, &na::convert(size));
let ray = Ray::new(pos, dir);
let hit = self.physics.query_pipeline.cast_ray(
&self.physics.colliders,
let physics = &self.harness.physics;
let hit = physics.query_pipeline.cast_ray(
&physics.colliders,
&ray,
f32::MAX,
InteractionGroups::all(),
);
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());
for node in self.graphics.body_nodes_mut(collider.parent()).unwrap() {
node.select()
@@ -1075,8 +1023,9 @@ impl State for Testbed {
if let Some(ui) = &mut self.ui {
ui.update(
window,
&mut self.physics.integration_parameters,
&mut self.harness.physics.integration_parameters,
&mut self.state,
&mut self.harness.state,
);
}
@@ -1123,7 +1072,7 @@ impl State for Testbed {
self.clear(window);
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);
@@ -1140,12 +1089,12 @@ impl State for Testbed {
.action_flags
.set(TestbedActionFlags::TAKE_SNAPSHOT, false);
self.state.snapshot = PhysicsSnapshot::new(
self.state.timestep_id,
&self.physics.broad_phase,
&self.physics.narrow_phase,
&self.physics.bodies,
&self.physics.colliders,
&self.physics.joints,
self.harness.state.timestep_id,
&self.harness.physics.broad_phase,
&self.harness.physics.narrow_phase,
&self.harness.physics.bodies,
&self.harness.physics.colliders,
&self.harness.physics.joints,
)
.ok();
@@ -1172,9 +1121,9 @@ impl State for Testbed {
}
self.set_world(w.3, w.4, w.5);
self.physics.broad_phase = w.1;
self.physics.narrow_phase = w.2;
self.state.timestep_id = w.0;
self.harness.physics.broad_phase = w.1;
self.harness.physics.narrow_phase = w.2;
self.harness.state.timestep_id = w.0;
}
}
}
@@ -1187,12 +1136,12 @@ impl State for Testbed {
self.state
.action_flags
.set(TestbedActionFlags::RESET_WORLD_GRAPHICS, false);
for (handle, _) in self.physics.bodies.iter() {
for (handle, _) in self.harness.physics.bodies.iter() {
self.graphics.add(
window,
handle,
&self.physics.bodies,
&self.physics.colliders,
&self.harness.physics.bodies,
&self.harness.physics.colliders,
);
}
@@ -1207,7 +1156,7 @@ impl State for Testbed {
!= self.state.flags.contains(TestbedStateFlags::WIREFRAME)
{
self.graphics.toggle_wireframe_mode(
&self.physics.colliders,
&self.harness.physics.colliders,
self.state.flags.contains(TestbedStateFlags::WIREFRAME),
)
}
@@ -1216,11 +1165,11 @@ impl State for Testbed {
!= 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();
}
} 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.activation.threshold = -1.0;
}
@@ -1233,7 +1182,10 @@ impl State for Testbed {
.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);
}
@@ -1283,48 +1235,13 @@ impl State for Testbed {
if self.state.running != RunMode::Stop {
for _ in 0..self.nsteps {
self.state.timestep_id += 1;
if self.state.selected_backend == RAPIER_BACKEND {
#[cfg(feature = "parallel")]
{
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);
let graphics = &mut self.graphics;
self.harness
.step_with_graphics(Some(window), Some(graphics));
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 {
self.box2d.as_mut().unwrap().step(
&mut self.physics.pipeline.counters,
&self.physics.integration_parameters,
&mut physics.pipeline.counters,
&physics.integration_parameters,
);
self.box2d
.as_mut()
.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");
self.physx.as_mut().unwrap().step(
&mut self.physics.pipeline.counters,
&self.physics.integration_parameters,
&mut physics.pipeline.counters,
&physics.integration_parameters,
);
self.physx
.as_mut()
.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 {
self.nphysics.as_mut().unwrap().step(
&mut self.physics.pipeline.counters,
&self.physics.integration_parameters,
&mut physics.pipeline.counters,
&physics.integration_parameters,
);
self.nphysics
.as_mut()
.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 {
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 {
// // !self.hide_counters {
// #[cfg(not(feature = "log"))]
@@ -1396,20 +1301,21 @@ impl State for Testbed {
// #[cfg(feature = "log")]
// debug!("{}", self.world.counters);
// }
self.time += self.physics.integration_parameters.dt();
}
}
self.highlight_hovered_body(window);
let physics = &self.harness.physics;
self.graphics
.draw(&self.physics.bodies, &self.physics.colliders, window);
.draw(&physics.bodies, &physics.colliders, window);
for plugin in &mut self.plugins {
plugin.draw();
}
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 {
@@ -1421,7 +1327,7 @@ impl State for Testbed {
}
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();
if self.state.flags.contains(TestbedStateFlags::PROFILE) {
@@ -1472,11 +1378,12 @@ CCD: {:.2}ms
if self.state.flags.contains(TestbedStateFlags::DEBUG) {
let t = instant::now();
let bf = bincode::serialize(&self.physics.broad_phase).unwrap();
let nf = bincode::serialize(&self.physics.narrow_phase).unwrap();
let bs = bincode::serialize(&self.physics.bodies).unwrap();
let cs = bincode::serialize(&self.physics.colliders).unwrap();
let js = bincode::serialize(&self.physics.joints).unwrap();
let physics = &self.harness.physics;
let bf = bincode::serialize(&physics.broad_phase).unwrap();
let nf = bincode::serialize(&physics.narrow_phase).unwrap();
let bs = bincode::serialize(&physics.bodies).unwrap();
let cs = bincode::serialize(&physics.colliders).unwrap();
let js = bincode::serialize(&physics.joints).unwrap();
let serialization_time = instant::now() - t;
let hash_bf = md5::compute(&bf);
let hash_nf = md5::compute(&nf);
@@ -1494,7 +1401,7 @@ Hashes at frame: {}
|_ Joints [{:.1}KB]: {:?}"#,
profile,
serialization_time,
self.state.timestep_id,
self.harness.state.timestep_id,
bf.len() as f32 / 1000.0,
hash_bf,
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 rapier::dynamics::IntegrationParameters;
use crate::harness::RunState;
use crate::testbed::{RunMode, TestbedActionFlags, TestbedState, TestbedStateFlags};
const SIDEBAR_W: f64 = 200.0;
@@ -98,6 +99,7 @@ impl TestbedUi {
window: &mut Window,
integration_parameters: &mut IntegrationParameters,
state: &mut TestbedState,
run_state: &mut RunState,
) {
let ui_root = window.conrod_ui().window;
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_pos_iters = integration_parameters.max_position_iterations;
#[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_min_island_size = integration_parameters.min_island_size;
let curr_warmstart_coeff = integration_parameters.warmstart_coeff;
@@ -305,10 +307,10 @@ impl TestbedUi {
.w_h(ELEMENT_W, ELEMENT_H)
.set(self.ids.slider_num_threads, &mut ui)
{
if state.num_threads != val as usize {
state.num_threads = val as usize;
state.thread_pool = rapier::rayon::ThreadPoolBuilder::new()
.num_threads(state.num_threads)
if run_state.num_threads != val as usize {
run_state.num_threads = val as usize;
run_state.thread_pool = rapier::rayon::ThreadPoolBuilder::new()
.num_threads(run_state.num_threads)
.build()
.unwrap();
}