cppbind: automatic conversion of SGReferenced derived pointers.

[simgear.git] / simgear / props / PropertyInterpolationMgr.cxx

diff --git a/simgear/props/PropertyInterpolationMgr.cxx b/simgear/props/PropertyInterpolationMgr.cxx
index 4f217a7888254c64b1e2f6bc8343df1af9f68b66..ad8060e2f59f8d3bb0413cd23e5ba4dad5cc5d34 100644 (file)
--- a/simgear/props/PropertyInterpolationMgr.cxx
+++ b/simgear/props/PropertyInterpolationMgr.cxx
@@ -18,13 +18,7 @@
 
 #include "PropertyInterpolationMgr.hxx"
 #include "PropertyInterpolator.hxx"
-
-#ifndef SIMGEAR_HEADLESS
-# include <simgear/scene/util/ColorInterpolator.hxx>
-#endif
-
-#include <simgear/props/props.hxx>
-#include <simgear_config.h>
+#include "props.hxx"
 
 #include <algorithm>
 
@@ -35,9 +29,6 @@ namespace simgear
   PropertyInterpolationMgr::PropertyInterpolationMgr()
   {
     addInterpolatorFactory<NumericInterpolator>("numeric");
-#ifndef SIMGEAR_HEADLESS
-    addInterpolatorFactory<ColorInterpolator>("color");
-#endif
 
     for( size_t i = 0; easing_functions[i].name; ++i )
       addEasingFunction
@@ -50,6 +41,9 @@ namespace simgear
   //----------------------------------------------------------------------------
   void PropertyInterpolationMgr::update(double dt)
   {
+    if( _rt_prop )
+      dt = _rt_prop->getDoubleValue();
+
     for( InterpolatorList::iterator it = _interpolators.begin();
                                     it != _interpolators.end();
                                   ++it )
@@ -57,7 +51,7 @@ namespace simgear
       for(double unused_time = dt;;)
       {
         PropertyInterpolatorRef interp = it->second;
-        unused_time = interp->update(it->first, unused_time);
+        unused_time = interp->update(*it->first, unused_time);
 
         if( unused_time <= 0.0 )
           // No time left for next animation
@@ -95,9 +89,9 @@ namespace simgear
   };
 
   //----------------------------------------------------------------------------
-  PropertyInterpolatorRef
+  PropertyInterpolator*
   PropertyInterpolationMgr::createInterpolator( const std::string& type,
-                                                const SGPropertyNode* target,
+                                                const SGPropertyNode& target,
                                                 double duration,
                                                 const std::string& easing )
   {
@@ -126,8 +120,9 @@ namespace simgear
       return 0;
     }
 
-    PropertyInterpolatorRef interp;
-    interp = (*interpolator_factory->second)(target);
+    PropertyInterpolator* interp;
+    interp = (*interpolator_factory->second)();
+    interp->reset(target);
     interp->_type = type;
     interp->_duration = duration;
     interp->_easing = easing_func->second;
@@ -136,9 +131,12 @@ namespace simgear
   }
 
   //----------------------------------------------------------------------------
-  void PropertyInterpolationMgr::interpolate( SGPropertyNode* prop,
+  bool PropertyInterpolationMgr::interpolate( SGPropertyNode* prop,
                                               PropertyInterpolatorRef interp )
   {
+    if( !prop )
+      return false;
+
     // Search for active interpolator on given property
     InterpolatorList::iterator it = std::find_if
     (
@@ -147,6 +145,14 @@ namespace simgear
       PredicateIsSameProp(prop)
     );
 
+    if( !interp )
+    {
+      // Without new interpolator just remove old one
+      if( it != _interpolators.end() )
+        _interpolators.erase(it);
+      return true;
+    }
+
     if( it != _interpolators.end() )
     {
       // Ensure no circular reference is left
@@ -158,6 +164,52 @@ namespace simgear
     }
     else
       _interpolators.push_front( std::make_pair(prop, interp) );
+
+    return true;
+  }
+
+  //----------------------------------------------------------------------------
+  bool PropertyInterpolationMgr::interpolate( SGPropertyNode* prop,
+                                              const std::string& type,
+                                              const SGPropertyNode& target,
+                                              double duration,
+                                              const std::string& easing )
+  {
+    return interpolate
+    (
+      prop,
+      createInterpolator(type, target, duration, easing)
+    );
+  }
+
+  //----------------------------------------------------------------------------
+  bool PropertyInterpolationMgr::interpolate( SGPropertyNode* prop,
+                                              const std::string& type,
+                                              const PropertyList& values,
+                                              const double_list& deltas,
+                                              const std::string& easing )
+  {
+    if( values.size() != deltas.size() )
+      SG_LOG(SG_GENERAL, SG_WARN, "interpolate: sizes do not match");
+
+    size_t num_values = std::min(values.size(), deltas.size());
+    PropertyInterpolatorRef first_interp, cur_interp;
+    for(size_t i = 0; i < num_values; ++i)
+    {
+      assert(values[i]);
+
+      PropertyInterpolator* interp =
+        createInterpolator(type, *values[i], deltas[i], easing);
+
+      if( !first_interp )
+        first_interp = interp;
+      else
+        cur_interp->_next = interp;
+
+      cur_interp = interp;
+    }
+
+    return interpolate(prop, first_interp);
   }
 
   //----------------------------------------------------------------------------
@@ -194,4 +246,10 @@ namespace simgear
     _easing_functions[type] = func;
   }
 
+  //----------------------------------------------------------------------------
+  void PropertyInterpolationMgr::setRealtimeProperty(SGPropertyNode* node)
+  {
+    _rt_prop = node;
+  }
+
 } // namespace simgear