#ifndef _MOOF_INTERPOLATOR_HH_
#define _MOOF_INTERPOLATOR_HH_
+#include <Moof/Log.hh>
#include <Moof/Math.hh>
{
if (value > 1.0)
{
- switch (mode_)
+ switch (mMode)
{
case STOP:
value = 1.0;
- stopped_ = true;
+ mDone = true;
break;
case REPEAT:
value -= 1.0;
break;
case OSCILLATE:
value = 2.0 - value;
- scale_ *= -1.0;
+ mScale *= -1.0;
break;
}
}
else if (value < 0.0)
{
- switch (mode_)
+ switch (mMode)
{
case STOP:
value = 0.0;
- stopped_ = true;
+ mDone = true;
break;
case REPEAT:
value += 1.0;
break;
case OSCILLATE:
value = -value;
- scale_ *= -1.0;
+ mScale *= -1.0;
break;
}
}
}
public:
+
typedef enum
{
STOP = 0,
void init(Scalar seconds = 1.0, Mode mode = STOP)
{
- scale_ = 1.0 / seconds;
- alpha_ = 0.0;
+ mScale = 1.0 / seconds;
+ mAlpha = 0.0;
setMode(mode);
}
void setMode(Mode mode)
{
- mode_ = mode;
- stopped_ = false;
+ mMode = mode;
+ mDone = false;
}
- void update(Scalar dt)
+ void update(Scalar t, Scalar dt)
{
- if (!stopped_)
+ if (!mDone)
{
- alpha_ += dt * scale_;
- clamp(alpha_);
- calculate(alpha_);
+ mAlpha += dt * mScale;
+ clamp(mAlpha);
+ calculate(mAlpha);
}
}
+ bool isDone() const
+ {
+ return mDone;
+ }
+
virtual void calculate(Scalar alpha) = 0;
private:
- Scalar alpha_;
- Mode mode_;
- Scalar scale_;
- bool stopped_;
+
+ Scalar mAlpha;
+ Mode mMode;
+ Scalar mScale;
+ bool mDone;
};
template <class T = Scalar>
class InterpolatorBase : public Interpolator
{
public:
+
void init(Scalar seconds = 1.0, Mode mode = STOP)
{
Interpolator::init(seconds, mode);
calculate(0.0); // set value
- previous_ = value_;
+ mPrevious = mValue;
}
void calculate(Scalar alpha)
{
- previous_ = value_;
- calculate(value_, alpha);
+ mPrevious = mValue;
+ calculate(mValue, alpha);
}
virtual void calculate(T& value, Scalar alpha) = 0;
const T& getValue() const
{
- return value_;
+ return mValue;
}
const T getState(Scalar alpha) const
{
- return cml::lerp(previous_, value_, alpha);
+ return cml::lerp(mPrevious, mValue, alpha);
}
private:
- T value_;
- T previous_;
+
+ T mValue;
+ T mPrevious;
};
class PolynomialInterpolator : public InterpolatorBase<T>
{
public:
+
PolynomialInterpolator() {}
PolynomialInterpolator(const T coefficients[D+1],
for (int i = 0; i <= D; ++i)
{
// n! / (k! * (n - k)!)
- coefficients_[i] = coefficients[i] * fac[D] / (fac[i] * fac[D - i]);
+ mCoefficients[i] = coefficients[i] * fac[D] / (fac[i] * fac[D - i]);
}
InterpolatorBase<T>::init(seconds, mode);
{
Scalar beta = 1.0 - alpha;
- value = coefficients_[0] * std::pow(beta, D);
+ value = mCoefficients[0] * std::pow(beta, D);
for (int i = 1; i <= D; ++i)
{
- value += coefficients_[i] * std::pow(beta, D - i) *
+ value += mCoefficients[i] * std::pow(beta, D - i) *
std::pow(alpha, i);
}
}
private:
- T coefficients_[D+1];
+
+ T mCoefficients[D+1];
};
class PolynomialInterpolator<1,T> : public InterpolatorBase<T>
{
public:
+
PolynomialInterpolator() {}
PolynomialInterpolator(const T coefficients[2], Scalar seconds = 1.0,
void init(const T coefficients[2], Scalar seconds = 1.0,
Interpolator::Mode mode = Interpolator::STOP)
{
- a_ = coefficients[0];
- b_ = coefficients[1];
+ mA = coefficients[0];
+ mB = coefficients[1];
InterpolatorBase<T>::init(seconds, mode);
}
void calculate(T& value, Scalar alpha)
{
- value = cml::lerp(a_, b_, alpha);
+ value = cml::lerp(mA, mB, alpha);
}
private:
- T a_;
- T b_;
+
+ T mA;
+ T mB;
};