minor refactoring and state progress

[chaz/yoink] / src / Moof / Interpolator.hh

diff --git a/src/Moof/Interpolator.hh b/src/Moof/Interpolator.hh
index 4de3f6974bd3a7ceeaf93945b9d7ca5323126c07..7ad38fe9d4ce22fafd7c98baf66db9226dc62c41 100644 (file)
--- a/src/Moof/Interpolator.hh
+++ b/src/Moof/Interpolator.hh
@@ -44,41 +44,42 @@ class Interpolator
        {
                if (value > 1.0)
                {
-                       switch (mode_)
+                       switch (mMode)
                        {
                                case STOP:
                                        value = 1.0;
-                                       done_ = 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;
-                                       done_ = 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,
@@ -88,77 +89,79 @@ public:
 
        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;
-               done_ = false;
+               mMode = mode;
+               mDone = false;
        }
 
 
        void update(Scalar t, Scalar dt)
        {
-               if (!done_)
+               if (!mDone)
                {
-                       alpha_ += dt * scale_;
-                       clamp(alpha_);
-                       calculate(alpha_);
+                       mAlpha += dt * mScale;
+                       clamp(mAlpha);
+                       calculate(mAlpha);
                }
        }
 
        bool isDone() const
        {
-               return done_;
+               return mDone;
        }
 
        virtual void calculate(Scalar alpha) = 0;
 
 private:
 
-       Scalar  alpha_;
-       Mode    mode_;
-       Scalar  scale_;
-       bool    done_;
+       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;
 };
 
 
@@ -166,6 +169,7 @@ template <int D, class T = Scalar>
 class PolynomialInterpolator : public InterpolatorBase<T>
 {
 public:
+
        PolynomialInterpolator() {}
 
        PolynomialInterpolator(const T coefficients[D+1],
@@ -192,7 +196,7 @@ public:
                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);
@@ -203,17 +207,18 @@ public:
        {
                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];
 };
 
 
@@ -223,6 +228,7 @@ template <class T>
 class PolynomialInterpolator<1,T> : public InterpolatorBase<T>
 {
 public:
+
        PolynomialInterpolator() {}
 
        PolynomialInterpolator(const T coefficients[2], Scalar seconds = 1.0,
@@ -235,8 +241,8 @@ public:
        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);
        }
@@ -244,12 +250,13 @@ public:
 
        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;
 };