#include "PropertyInterpolationMgr.hxx"
#include "PropertyInterpolator.hxx"
-
-#include <simgear_config.h>
-
-#ifndef SIMGEAR_HEADLESS
-# include <simgear/scene/util/ColorInterpolator.hxx>
-#endif
-
-#include <simgear/props/props.hxx>
+#include "props.hxx"
#include <algorithm>
PropertyInterpolationMgr::PropertyInterpolationMgr()
{
addInterpolatorFactory<NumericInterpolator>("numeric");
-#ifndef SIMGEAR_HEADLESS
- addInterpolatorFactory<ColorInterpolator>("color");
-#endif
for( size_t i = 0; easing_functions[i].name; ++i )
addEasingFunction
//----------------------------------------------------------------------------
void PropertyInterpolationMgr::update(double dt)
{
+ if( _rt_prop )
+ dt = _rt_prop->getDoubleValue();
+
for( InterpolatorList::iterator it = _interpolators.begin();
it != _interpolators.end();
++it )
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
};
//----------------------------------------------------------------------------
- PropertyInterpolatorRef
+ PropertyInterpolator*
PropertyInterpolationMgr::createInterpolator( const std::string& type,
- const SGPropertyNode* target,
+ const SGPropertyNode& target,
double duration,
const std::string& easing )
{
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;
}
//----------------------------------------------------------------------------
- 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
(
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
}
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);
}
//----------------------------------------------------------------------------
_easing_functions[type] = func;
}
+ //----------------------------------------------------------------------------
+ void PropertyInterpolationMgr::setRealtimeProperty(SGPropertyNode* node)
+ {
+ _rt_prop = node;
+ }
+
} // namespace simgear