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

Merge branch 'master' into split_geom

Browse Source 
# Conflicts:
#	examples2d/sensor2.rs
#	examples3d/sensor3.rs
#	src/dynamics/integration_parameters.rs
#	src/dynamics/solver/parallel_island_solver.rs
#	src/dynamics/solver/velocity_constraint.rs
#	src/dynamics/solver/velocity_ground_constraint.rs
#	src_testbed/nphysics_backend.rs
#	src_testbed/physx_backend.rs
#	src_testbed/testbed.rs
This commit is contained in:
Crozet Sébastien
2021-01-22 16:10:24 +01:00
parent 800b35b103 e6fc8f67fa
commit cf52e01308
24 changed files with 359 additions and 356 deletions
Download Patch File Download Diff File Expand all files Collapse all files

75
src/dynamics/integration_parameters.rs
View File

@@ -5,9 +5,8 @@ use crate::math::Real;
#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
pub struct IntegrationParameters {
/// The timestep length (default: `1.0 / 60.0`)
dt: Real,
/// The inverse of `dt`.
inv_dt: Real,
pub dt: Real,
// /// If `true` and if rapier is compiled with the `parallel` feature, this will enable rayon-based multithreading (default: `true`).
// ///
// /// This parameter is ignored if rapier is not compiled with is `parallel` feature.
@@ -31,7 +30,7 @@ pub struct IntegrationParameters {
/// Contacts at points where the involved bodies have a relative
/// velocity smaller than this threshold wont be affected by the restitution force (default: `1.0`).
pub restitution_velocity_threshold: Real,
/// Amount of penetration the engine wont attempt to correct (default: `0.001m`).
/// Amount of penetration the engine wont attempt to correct (default: `0.005m`).
pub allowed_linear_error: Real,
/// The maximal distance separating two objects that will generate predictive contacts (default: `0.002`).
pub prediction_distance: Real,
@@ -89,6 +88,7 @@ pub struct IntegrationParameters {
impl IntegrationParameters {
/// Creates a set of integration parameters with the given values.
#[deprecated = "Use `IntegrationParameters { dt: 60.0, ..Default::default() }` instead"]
pub fn new(
dt: Real,
// multithreading_enabled: bool,
@@ -112,7 +112,6 @@ impl IntegrationParameters {
) -> Self {
IntegrationParameters {
dt,
inv_dt: if dt == 0.0 { 0.0 } else { 1.0 / dt },
// multithreading_enabled,
erp,
joint_erp,
@@ -142,30 +141,29 @@ impl IntegrationParameters {
/// The current time-stepping length.
#[inline(always)]
#[deprecated = "You can just read the `IntegrationParams::dt` value directly"]
pub fn dt(&self) -> Real {
self.dt
}
/// The inverse of the time-stepping length.
/// The inverse of the time-stepping length, i.e. the steps per seconds (Hz).
///
/// This is zero if `self.dt` is zero.
#[inline(always)]
pub fn inv_dt(&self) -> Real {
self.inv_dt
if self.dt == 0.0 {
0.0
} else {
1.0 / self.dt
}
}
/// Sets the time-stepping length.
///
/// This automatically recompute `self.inv_dt`.
#[inline]
#[deprecated = "You can just set the `IntegrationParams::dt` value directly"]
pub fn set_dt(&mut self, dt: Real) {
assert!(dt >= 0.0, "The time-stepping length cannot be negative.");
self.dt = dt;
if dt == 0.0 {
self.inv_dt = 0.0
} else {
self.inv_dt = 1.0 / dt
}
}
/// Sets the inverse time-stepping length (i.e. the frequency).
@@ -173,7 +171,6 @@ impl IntegrationParameters {
/// This automatically recompute `self.dt`.
#[inline]
pub fn set_inv_dt(&mut self, inv_dt: Real) {
self.inv_dt = inv_dt;
if inv_dt == 0.0 {
self.dt = 0.0
} else {
@@ -184,26 +181,32 @@ impl IntegrationParameters {
impl Default for IntegrationParameters {
fn default() -> Self {
Self::new(
1.0 / 60.0,
// true,
0.2,
0.2,
1.0,
1.0,
0.005,
0.001,
0.2,
0.2,
0.002,
0.2,
4,
1,
10,
1,
false,
false,
false,
)
Self {
dt: 1.0 / 60.0,
// multithreading_enabled: true,
return_after_ccd_substep: false,
erp: 0.2,
joint_erp: 0.2,
warmstart_coeff: 1.0,
restitution_velocity_threshold: 1.0,
allowed_linear_error: 0.005,
prediction_distance: 0.002,
allowed_angular_error: 0.001,
max_linear_correction: 0.2,
max_angular_correction: 0.2,
max_stabilization_multiplier: 0.2,
max_velocity_iterations: 4,
max_position_iterations: 1,
// FIXME: what is the optimal value for min_island_size?
// It should not be too big so that we don't end up with
// huge islands that don't fit in cache.
// However we don't want it to be too small and end up with
// tons of islands, reducing SIMD parallelism opportunities.
min_island_size: 128,
max_ccd_position_iterations: 10,
max_ccd_substeps: 1,
multiple_ccd_substep_sensor_events_enabled: false,
ccd_on_penetration_enabled: false,
}
}
}

3
src/dynamics/solver/island_solver.rs
View File

@@ -57,8 +57,7 @@ impl IslandSolver {
}
counters.solver.velocity_update_time.resume();
bodies
.foreach_active_island_body_mut_internal(island_id, |_, rb| rb.integrate(params.dt()));
bodies.foreach_active_island_body_mut_internal(island_id, |_, rb| rb.integrate(params.dt));
counters.solver.velocity_update_time.pause();
if manifold_indices.len() != 0 || joint_indices.len() != 0 {

2
src/dynamics/solver/parallel_island_solver.rs
View File

@@ -251,7 +251,7 @@ impl ParallelIslandSolver {
let dvel = mj_lambdas[rb.active_set_offset];
rb.linvel += dvel.linear;
rb.angvel += rb.effective_world_inv_inertia_sqrt.transform_vector(dvel.angular);
rb.integrate(params.dt());
rb.integrate(params.dt));
positions[rb.active_set_offset] = rb.position;
}
}

3
src/dynamics/solver/velocity_constraint.rs
View File

@@ -144,6 +144,7 @@ impl VelocityConstraint {
out_constraints: &mut Vec<AnyVelocityConstraint>,
push: bool,
) {
let inv_dt = params.inv_dt();
let rb1 = &bodies[manifold.data.body_pair.body1];
let rb2 = &bodies[manifold.data.body_pair.body2];
let mj_lambda1 = rb1.active_set_offset;
@@ -244,7 +245,7 @@ impl VelocityConstraint {
rhs += manifold_point.restitution * rhs
}
rhs += manifold_point.dist.max(0.0) * params.inv_dt();
rhs += manifold_point.dist.max(0.0) * inv_dt;
let impulse = manifold_point.data.impulse * warmstart_coeff;

3
src/dynamics/solver/velocity_ground_constraint.rs
View File

@@ -63,6 +63,7 @@ impl VelocityGroundConstraint {
out_constraints: &mut Vec<AnyVelocityConstraint>,
push: bool,
) {
let inv_dt = params.inv_dt();
let mut rb1 = &bodies[manifold.data.body_pair.body1];
let mut rb2 = &bodies[manifold.data.body_pair.body2];
let flipped = !rb2.is_dynamic();
@@ -159,7 +160,7 @@ impl VelocityGroundConstraint {
rhs += manifold_point.restitution * rhs
}
rhs += manifold_point.dist.max(0.0) * params.inv_dt();
rhs += manifold_point.dist.max(0.0) * inv_dt;
let impulse = manifold_points[k].data.impulse * warmstart_coeff;