Use a separate smoothing timer for steering

src/karts/kart_rewinder.cpp

@@ -40,6 +40,8 @@ KartRewinder::KartRewinder(const std::string& ident,unsigned int world_kart_id,
             , Kart(ident, world_kart_id, position, init_transform, difficulty,
                    ri)
 {
+    m_steering_smoothing_dt = -1.0f;
+    m_prev_steering = m_steering_smoothing_time = 0.0f;
 }   // KartRewinder
 
 // ----------------------------------------------------------------------------
@@ -61,6 +63,7 @@ void KartRewinder::saveTransform()
 {
     if (!getKartAnimation())
         Moveable::prepareSmoothing();
+
     m_prev_steering = getSteerPercent();
 }   // saveTransform
 
@@ -69,21 +72,16 @@ void KartRewinder::computeError()
 {
     if (!getKartAnimation())
         Moveable::checkSmoothing();
-}   // computeError
 
-// ----------------------------------------------------------------------------
-float KartRewinder::getSteerPercent() const
-{
-    if (m_smoothing == SS_TO_ADJUST)
+    float diff = fabsf(m_prev_steering - AbstractKart::getSteerPercent());
+    if (diff > 0.05f)
     {
-        float ratio = m_adjust_time_dt / m_adjust_time;
-        if (ratio > 1.0f)
-            ratio = 1.0f;
-        return ratio * AbstractKart::getSteerPercent() +
-            (1.0f - ratio) * m_prev_steering;
+        m_steering_smoothing_time = getTimeFullSteer(diff) / 2.0f;
+        m_steering_smoothing_dt = 0.0f;
     }
-    return AbstractKart::getSteerPercent();
-}   // getSteerPercent
+    else
+        m_steering_smoothing_dt = -1.0f;
+}   // computeError
 
 // ----------------------------------------------------------------------------
 /** Saves all state information for a kart in a memory buffer. The memory

src/karts/kart_rewinder.hpp

@@ -34,7 +34,7 @@ private:
     enum { EVENT_CONTROL = 0x01,
            EVENT_ATTACH  = 0x02 };
 
-    float m_prev_steering;
+    float m_prev_steering, m_steering_smoothing_dt, m_steering_smoothing_time;
 
 public:
     KartRewinder(const std::string& ident, unsigned int world_kart_id,
@@ -49,7 +49,27 @@ public:
     virtual void restoreState(BareNetworkString *p, int count) OVERRIDE;
     virtual void rewindToEvent(BareNetworkString *p) OVERRIDE;
     virtual void update(int ticks) OVERRIDE;
-    virtual float getSteerPercent() const OVERRIDE;
+    // -------------------------------------------------------------------------
+    virtual float getSteerPercent() const OVERRIDE
+    {
+        if (m_steering_smoothing_dt >= 0.0f)
+        {
+            return m_steering_smoothing_dt * AbstractKart::getSteerPercent() +
+                (1.0f - m_steering_smoothing_dt) * m_prev_steering;
+        }
+        return AbstractKart::getSteerPercent();
+    }
+    // -------------------------------------------------------------------------
+    virtual void updateGraphics(float dt) OVERRIDE
+    {
+        if (m_steering_smoothing_dt >= 0.0f)
+        {
+            m_steering_smoothing_dt += dt / m_steering_smoothing_time;
+            if (m_steering_smoothing_dt > 1.0f)
+                m_steering_smoothing_dt = -1.0f;
+        }
+        Kart::updateGraphics(dt);
+    }
     // -------------------------------------------------------------------------
     virtual void undoState(BareNetworkString *p) OVERRIDE {}
     // -------------------------------------------------------------------------

src/karts/moveable.hpp

@@ -41,7 +41,7 @@ class Material;
   */
 class Moveable: public NoCopy
 {
-protected:
+private:
     enum SmoothingState
     {
         SS_NONE = 0,
@@ -49,11 +49,6 @@ protected:
         SS_TO_REAL
     };
 
-    float m_adjust_time, m_adjust_time_dt;
-
-    SmoothingState m_smoothing;
-
-private:
     Vec3                   m_velocityLC;      /**<Velocity in kart coordinates. */
     /** The bullet transform of this rigid body. */
     btTransform            m_transform;
@@ -76,6 +71,10 @@ private:
 
     btTransform m_smoothed_transform;
 
+    float m_adjust_time, m_adjust_time_dt;
+
+    SmoothingState m_smoothing;
+
 protected:
     UserPointer            m_user_pointer;
     scene::IMesh          *m_mesh;