1 files changed, 30 insertions, 4 deletions

diff --git a/src/dynamics/rigid_body.rs b/src/dynamics/rigid_body.rs
index a2fcacc..af1fb4a 100644
--- a/src/dynamics/rigid_body.rs
+++ b/src/dynamics/rigid_body.rs
@@ -137,6 +137,15 @@ impl RigidBody {
         crate::utils::inv(self.mass_properties.inv_mass)
     }
 
+    /// The predicted position of this rigid-body.
+    ///
+    /// If this rigid-body is kinematic this value is set by the `set_next_kinematic_position`
+    /// method and is used for estimating the kinematic body velocity at the next timestep.
+    /// For non-kinematic bodies, this value is currently unspecified.
+    pub fn predicted_position(&self) -> &Isometry<f32> {
+        &self.predicted_position
+    }
+
     /// Adds a collider to this rigid-body.
     pub(crate) fn add_collider_internal(&mut self, handle: ColliderHandle, coll: &Collider) {
         let mass_properties = coll
@@ -172,10 +181,13 @@ impl RigidBody {
     }
 
     /// Wakes up this rigid body if it is sleeping.
-    pub fn wake_up(&mut self) {
+    ///
+    /// If `strong` is `true` then it is assured that the rigid-body will
+    /// remain awake during multiple subsequent timesteps.
+    pub fn wake_up(&mut self, strong: bool) {
         self.activation.sleeping = false;
 
-        if self.activation.energy == 0.0 && self.is_dynamic() {
+        if (strong || self.activation.energy == 0.0) && self.is_dynamic() {
             self.activation.energy = self.activation.threshold.abs() * 2.0;
         }
     }
@@ -189,9 +201,18 @@ impl RigidBody {
 
     /// Is this rigid body sleeping?
     pub fn is_sleeping(&self) -> bool {
+        // TODO: should we:
+        // - return false for static bodies.
+        // - return true for non-sleeping dynamic bodies.
+        // - return true only for kinematic bodies with non-zero velocity?
         self.activation.sleeping
     }
 
+    /// Is the velocity of this body not zero?
+    pub fn is_moving(&self) -> bool {
+        !self.linvel.is_zero() || !self.angvel.is_zero()
+    }
+
     fn integrate_velocity(&self, dt: f32) -> Isometry<f32> {
         let com = &self.position * self.mass_properties.local_com;
         let shift = Translation::from(com.coords);
@@ -201,12 +222,17 @@ impl RigidBody {
         self.position = self.integrate_velocity(dt) * self.position;
     }
 
-    /// Sets the position of this rigid body.
+    /// Sets the position and `next_kinematic_position` of this rigid body.
+    ///
+    /// This will teleport the rigid-body to the specified position/orientation,
+    /// completely ignoring any physics rule. If this body is kinematic, this will
+    /// also set the next kinematic position to the same value, effectively
+    /// resetting to zero the next interpolated velocity of the kinematic body.
     pub fn set_position(&mut self, pos: Isometry<f32>) {
         self.position = pos;
 
         // TODO: update the predicted position for dynamic bodies too?
-        if self.is_static() {
+        if self.is_static() || self.is_kinematic() {
             self.predicted_position = pos;
         }
     }