Struct PhysicsPipeline 

pub struct PhysicsPipeline {
    pub counters: Counters,
    /* private fields */
}

The main physics simulation engine that runs your physics world forward in time.

Think of this as the “game loop” for your physics simulation. Each frame, you call PhysicsPipeline::step to advance the simulation by one timestep. This structure handles all the complex physics calculations: detecting collisions between objects, resolving contacts so objects don’t overlap, and updating positions and velocities.

Performance note

This structure only contains temporary working memory (scratch buffers). You can create a new one anytime, but it’s more efficient to reuse the same instance across frames since Rapier can reuse allocated memory.

How it works (simplified)

Rapier uses a time-stepping approach where each step involves:

1. Collision detection: Find which objects are touching or overlapping
2. Constraint solving: Calculate forces to prevent overlaps and enforce joint constraints
3. Integration: Update object positions and velocities based on forces and gravity
4. Position correction: Fix any remaining overlaps that might have occurred

Fields

counters: Counters

Counters used for benchmarking only.

Implementations

impl PhysicsPipeline

pub fn new() -> PhysicsPipeline

Creates a new physics pipeline.

Call this once when setting up your physics world. The pipeline can be reused across multiple frames for better performance.

pub fn step( &mut self, gravity: &Vector<f32>, integration_parameters: &IntegrationParameters, islands: &mut IslandManager, broad_phase: &mut BroadPhaseBvh, narrow_phase: &mut NarrowPhase, bodies: &mut RigidBodySet, colliders: &mut ColliderSet, impulse_joints: &mut ImpulseJointSet, multibody_joints: &mut MultibodyJointSet, ccd_solver: &mut CCDSolver, hooks: &dyn PhysicsHooks, events: &dyn EventHandler, )

Advances the physics simulation by one timestep.

This is the main function you’ll call every frame in your game loop. It performs all physics calculations: collision detection, constraint solving, and updating object positions.

Parameters

• gravity - The gravity vector applied to all dynamic bodies (e.g., vector![0.0, -9.81, 0.0] for Earth gravity pointing down)
• integration_parameters - Controls the simulation quality and timestep size (typically 60 Hz = 1/60 second per step)
• islands - Internal system that groups connected objects together for efficient solving (automatically managed)
• broad_phase - Fast collision detection phase that filters out distant object pairs (automatically managed)
• narrow_phase - Precise collision detection that computes exact contact points (automatically managed)
• bodies - Your collection of rigid bodies (the physical objects that move and collide)
• colliders - The collision shapes attached to your bodies (boxes, spheres, meshes, etc.)
• impulse_joints - Regular joints connecting bodies (hinges, sliders, etc.)
• multibody_joints - Articulated joints for robot-like structures (optional, can be empty)
• ccd_solver - Continuous collision detection to prevent fast objects from tunneling through thin walls
• hooks - Optional callbacks to customize collision filtering and contact modification
• events - Optional handler to receive collision events (when objects start/stop touching)

Example

// In your game loop:
physics_pipeline.step(
    &vector![0.0, -9.81, 0.0],  // Gravity pointing down
    &integration_parameters,
    &mut islands,
    &mut broad_phase,
    &mut narrow_phase,
    &mut bodies,
    &mut colliders,
    &mut impulse_joints,
    &mut multibody_joints,
    &mut ccd_solver,
    &(),  // No custom hooks
    &(),  // No event handler
);

Trait Implementations

impl Default for PhysicsPipeline

fn default() -> Self

Returns the “default value” for a type.