Struct KinematicCharacterController 

pub struct KinematicCharacterController {
    pub up: UnitVector<f32>,
    pub offset: CharacterLength,
    pub slide: bool,
    pub autostep: Option<CharacterAutostep>,
    pub max_slope_climb_angle: f32,
    pub min_slope_slide_angle: f32,
    pub snap_to_ground: Option<CharacterLength>,
    pub normal_nudge_factor: f32,
}

A kinematic character controller for player/NPC movement (walking, climbing, sliding).

This provides classic game character movement: walking on floors, sliding on slopes, climbing stairs, and snapping to ground. It’s kinematic (not physics-based), meaning you control movement directly rather than applying forces.

Not suitable for: Ragdolls, vehicles, or physics-driven movement (use dynamic bodies instead).

How it works

1. You provide desired movement (e.g., “move forward 5 units”)
2. Controller casts the character shape through the world
3. It handles collisions: sliding along walls, stepping up stairs, snapping to ground
4. Returns the final movement to apply

Example

let controller = KinematicCharacterController {
    slide: true,  // Slide along walls instead of stopping
    autostep: Some(CharacterAutostep::default()),  // Auto-climb stairs
    max_slope_climb_angle: 45.0_f32.to_radians(),  // Max climbable slope
    ..Default::default()
};

// In your game loop:
let desired_movement = vector![input_x, 0.0, input_z] * speed * dt;
let movement = controller.move_shape(
    dt,
    &query_pipeline,
    &character_shape,
    &character_pos,
    desired_movement,
    |_| {}  // Collision event callback
);
character_pos.translation.vector += movement.translation;

Fields

up: UnitVector<f32>

The direction that goes “up”. Used to determine where the floor is, and the floor’s angle.

offset: CharacterLength

A small gap to preserve between the character and its surroundings.

This value should not be too large to avoid visual artifacts, but shouldn’t be too small (must not be zero) to improve numerical stability of the character controller.

slide: bool

Should the character try to slide against the floor if it hits it?

autostep: Option<CharacterAutostep>

Should the character automatically step over small obstacles? (disabled by default)

Note that autostepping is currently a very computationally expensive feature, so it is disabled by default.

max_slope_climb_angle: f32

The maximum angle (radians) between the floor’s normal and the up vector that the character is able to climb.

min_slope_slide_angle: f32

The minimum angle (radians) between the floor’s normal and the up vector before the character starts to slide down automatically.

snap_to_ground: Option<CharacterLength>

Should the character be automatically snapped to the ground if the distance between the ground and its feed are smaller than the specified threshold?

normal_nudge_factor: f32

Increase this number if your character appears to get stuck when sliding against surfaces.

This is a small distance applied to the movement toward the contact normals of shapes hit by the character controller. This helps shape-casting not getting stuck in an always-penetrating state during the sliding calculation.

This value should remain fairly small since it can introduce artificial “bumps” when sliding along a flat surface.

Implementations

impl KinematicCharacterController

pub fn move_shape( &self, dt: f32, queries: &QueryPipeline<'_>, character_shape: &dyn Shape, character_pos: &Isometry<f32>, desired_translation: Vector<f32>, events: impl FnMut(CharacterCollision), ) -> EffectiveCharacterMovement

Computes the possible movement for a shape.

pub fn solve_character_collision_impulses<'a>( &self, dt: f32, queries: &mut QueryPipelineMut<'_>, character_shape: &dyn Shape, character_mass: f32, collisions: impl IntoIterator<Item = &'a CharacterCollision>, )

For the given collisions between a character and its environment, this method will apply impulses to the rigid-bodies surrounding the character shape at the time of the collisions. Note that the impulse calculation is only approximate as it is not based on a global constraints resolution scheme.

Trait Implementations

impl Clone for KinematicCharacterController

fn clone(&self) -> KinematicCharacterController

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for KinematicCharacterController

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

Formats the value using the given formatter.

impl Default for KinematicCharacterController

fn default() -> Self

Returns the “default value” for a type.

impl Copy for KinematicCharacterController