Struct IntegrationParameters

pub struct IntegrationParameters {

    pub dt: Option<f32>,
    pub min_ccd_dt: f32,
    pub contact_damping_ratio: f32,
    pub contact_natural_frequency: f32,
    pub joint_natural_frequency: f32,
    pub joint_damping_ratio: f32,
    pub allowed_linear_error: f32,
    pub normalized_max_corrective_velocity: f32,
    pub prediction_distance: f32,
    pub num_solver_iterations: usize,
    pub num_additional_friction_iterations: usize,
    pub num_internal_pgs_iterations: usize,
    pub min_island_size: u32,
    pub max_ccd_substeps: u32,
    pub warmstart_coefficient: f32,
    pub length_unit: f32,
    pub num_internal_stabilization_iterations: usize,
}

Parameters for a time-step of the physics engine.

Notes

This is almost one-to-one copy of Rapier’s integration parameters with custom attributes for each parameter.

Fields

dt: Option<f32>

The time step length, default is None - this means that physics simulation will use engine’s time step.

min_ccd_dt: f32

Minimum timestep size when using CCD with multiple substeps (default 1.0 / 60.0 / 100.0)

When CCD with multiple substeps is enabled, the timestep is subdivided into smaller pieces. This timestep subdivision won’t generate timestep lengths smaller than min_ccd_dt.

Setting this to a large value will reduce the opportunity to performing CCD substepping, resulting in potentially more time dropped by the motion-clamping mechanism. Setting this to an very small value may lead to numerical instabilities.

contact_damping_ratio: f32

The damping ratio used by the springs for contact constraint stabilization. Larger values make the constraints more compliant (allowing more visible penetrations before stabilization). Default 5.0.

contact_natural_frequency: f32

The natural frequency used by the springs for contact constraint regularization. Increasing this value will make it so that penetrations get fixed more quickly at the expense of potential jitter effects due to overshooting. In order to make the simulation look stiffer, it is recommended to increase the contact_damping_ratio instead of this value. Default: 30.0

joint_natural_frequency: f32

The natural frequency used by the springs for joint constraint regularization. Increasing this value will make it so that penetrations get fixed more quickly. Default: 1.0e6

joint_damping_ratio: f32

The fraction of critical damping applied to the joint for constraints regularization. (default 0.8).

allowed_linear_error: f32

Amount of penetration the engine wont attempt to correct (default: 0.002m).

normalized_max_corrective_velocity: f32

Maximum amount of penetration the solver will attempt to resolve in one timestep (default: 10.0).

prediction_distance: f32

The maximal distance separating two objects that will generate predictive contacts (default: 0.002).

num_solver_iterations: usize

The number of solver iterations run by the constraints solver for calculating forces (default: 4).

num_additional_friction_iterations: usize

Number of addition friction resolution iteration run during the last solver sub-step (default: 4).

num_internal_pgs_iterations: usize

Number of internal Project Gauss Seidel (PGS) iterations run at each solver iteration (default: 1).

min_island_size: u32

Minimum number of dynamic bodies in each active island (default: 128).

max_ccd_substeps: u32

Maximum number of substeps performed by the solver (default: 4).

warmstart_coefficient: f32

The coefficient in [0, 1] applied to warmstart impulses, i.e., impulses that are used as the initial solution (instead of 0) at the next simulation step. Default 1.0.

length_unit: f32

The approximate size of most dynamic objects in the scene.

This value can be understood as the number of units-per-meter in your physical world compared to a human-sized world in meter. For example, in a 2d game, if your typical object size is 100 pixels, set the [Self::length_unit] parameter to 100.0. The physics engine will interpret it as if 100 pixels is equivalent to 1 meter in its various internal threshold. (default 1.0).

num_internal_stabilization_iterations: usize

The number of stabilization iterations run at each solver iterations (default: 2).

Implementations

impl IntegrationParameters

pub const DT: &'static str = "dt"

pub const MIN_CCD_DT: &'static str = "min_ccd_dt"

pub const CONTACT_DAMPING_RATIO: &'static str = "contact_damping_ratio"

pub const CONTACT_NATURAL_FREQUENCY: &'static str = "contact_natural_frequency"

pub const JOINT_NATURAL_FREQUENCY: &'static str = "joint_natural_frequency"

pub const JOINT_DAMPING_RATIO: &'static str = "joint_damping_ratio"

pub const ALLOWED_LINEAR_ERROR: &'static str = "allowed_linear_error"

pub const NORMALIZED_MAX_CORRECTIVE_VELOCITY: &'static str = "normalized_max_corrective_velocity"

pub const PREDICTION_DISTANCE: &'static str = "prediction_distance"

pub const NUM_SOLVER_ITERATIONS: &'static str = "num_solver_iterations"

pub const NUM_ADDITIONAL_FRICTION_ITERATIONS: &'static str = "num_additional_friction_iterations"

pub const NUM_INTERNAL_PGS_ITERATIONS: &'static str = "num_internal_pgs_iterations"

pub const MIN_ISLAND_SIZE: &'static str = "min_island_size"

pub const MAX_CCD_SUBSTEPS: &'static str = "max_ccd_substeps"

pub const WARMSTART_COEFFICIENT: &'static str = "warmstart_coefficient"

pub const LENGTH_UNIT: &'static str = "length_unit"

pub const NUM_INTERNAL_STABILIZATION_ITERATIONS: &'static str = "num_internal_stabilization_iterations"

Trait Implementations

impl Clone for IntegrationParameters

fn clone(&self) -> IntegrationParameters

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for IntegrationParameters

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for IntegrationParameters

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for IntegrationParameters

fn eq(&self, other: &IntegrationParameters) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Reflect for IntegrationParameters

where Self: 'static, Option<f32>: Reflect, f32: Reflect, usize: Reflect, u32: Reflect,

fn source_path() -> &'static str

fn type_name(&self) -> &'static str

fn doc(&self) -> &'static str

fn assembly_name(&self) -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn type_assembly_name() -> &'static str

Returns a parent assembly name of the type that implements this trait. WARNING: You should use proc-macro (#[derive(Reflect)]) to ensure that this method will return correct assembly name. In other words - there’s no guarantee, that any implementation other than proc-macro will return a correct name of the assembly. Alternatively, you can use env!("CARGO_PKG_NAME") as an implementation.

fn fields_info(&self, func: &mut dyn FnMut(&[FieldInfo<'_, '_>]))

fn into_any(self: Box<Self>) -> Box<dyn Any>

fn set( &mut self, value: Box<dyn Reflect>, ) -> Result<Box<dyn Reflect>, Box<dyn Reflect>>

fn as_any(&self, func: &mut dyn FnMut(&dyn Any))

fn as_any_mut(&mut self, func: &mut dyn FnMut(&mut dyn Any))

fn as_reflect(&self, func: &mut dyn FnMut(&dyn Reflect))

fn as_reflect_mut(&mut self, func: &mut dyn FnMut(&mut dyn Reflect))

fn fields(&self, func: &mut dyn FnMut(&[&dyn Reflect]))

fn fields_mut(&mut self, func: &mut dyn FnMut(&mut [&mut dyn Reflect]))

fn field(&self, name: &str, func: &mut dyn FnMut(Option<&dyn Reflect>))

fn field_mut( &mut self, name: &str, func: &mut dyn FnMut(Option<&mut dyn Reflect>), )

fn set_field( &mut self, field: &str, value: Box<dyn Reflect>, func: &mut dyn FnMut(Result<Box<dyn Reflect>, Box<dyn Reflect>>), )

Calls user method specified with #[reflect(setter = ..)] or falls back to Reflect::field_mut

fn as_array(&self, func: &mut dyn FnMut(Option<&(dyn ReflectArray + 'static)>))

fn as_array_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectArray + 'static)>), )

fn as_list(&self, func: &mut dyn FnMut(Option<&(dyn ReflectList + 'static)>))

fn as_list_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectList + 'static)>), )

fn as_inheritable_variable( &self, func: &mut dyn FnMut(Option<&(dyn ReflectInheritableVariable + 'static)>), )

fn as_inheritable_variable_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectInheritableVariable + 'static)>), )

fn as_hash_map( &self, func: &mut dyn FnMut(Option<&(dyn ReflectHashMap + 'static)>), )

fn as_hash_map_mut( &mut self, func: &mut dyn FnMut(Option<&mut (dyn ReflectHashMap + 'static)>), )

impl Visit for IntegrationParameters

where Option<f32>: Visit, f32: Visit, usize: Visit, u32: Visit,

fn visit(&mut self, name: &str, visitor: &mut Visitor) -> VisitResult

Read or write this value, depending on whether Visitor::is_reading() is true or false.

impl Copy for IntegrationParameters

impl StructuralPartialEq for IntegrationParameters