C:/Work/specialnumbers_svn/NumberLib/NumbersLib/BufferedState.h

Go to the documentation of this file.

#ifndef _BUFFERED_STATE_H
#define _BUFFERED_STATE_H

#include "Numbers.h"
#include "ClampedNumber.h"

namespace luma
{
namespace numbers
{

template <unsigned int n>
class BufferedState : public UpdateableNumber<unsigned int>
{
private:

   class DefaultClampedFloat : public ClampedNumber<float>
   {
   public:
      DefaultClampedFloat(float increment = 0.1f);
      
      void setIncrement(float increment);

      //DefaultClampedFloat& operator=(const float& value);
   
   };

   DefaultClampedFloat mStateValues[n];
   float mThresholds[n];
   unsigned int mState;

public:

   BufferedState(unsigned int initialState, float stateValues[], float thresholds[], float increment);

   BufferedState(const BufferedState& other);

   void setValue(unsigned int state, float ellapsedTime = 1);

   unsigned int getValue() const;

   void forceValue(int state);
};

template <unsigned int n>
BufferedState<n>::DefaultClampedFloat::DefaultClampedFloat(float increment):
   ClampedNumber<float>(0.0f, 0.0f, 1.0f, increment)
{};
      
template <unsigned int n>
void BufferedState<n>::DefaultClampedFloat::setIncrement(float increment)
{
   modify(mMin, mMax, increment);
}

/*template <unsigned int n>
typename BufferedState<n>::DefaultClampedFloat& BufferedState<n>::DefaultClampedFloat::operator=(const float& value)
{
   return dynamic_cast<DefaultClampedFloat&>(ClampedNumber<float>::operator=(value));
}*/

template <unsigned int n>
BufferedState<n>::BufferedState(unsigned int initialState, float stateValues[], float thresholds[], float increment):
   mState(initialState)
{
   for (unsigned int i = 0; i < n; i++)
   {
      mStateValues[i].setIncrement(increment);
      mStateValues[i].setValue(stateValues[i]);
      mThresholds[i] = thresholds[i];
   }
}

template <unsigned int n>
BufferedState<n>::BufferedState(const BufferedState& other):
   mState(other.mState)
{
   for (unsigned int i = 0; i < n; i++)
   {
      mStateValues[i] = other.mStateValues[i];
      mThresholds[i] = other.mThresholds[i];
   }
}

template <unsigned int n>
void BufferedState<n>::setValue(unsigned int state, float ellapsedTime)
{
   mStateValues[state].inc(ellapsedTime);

   if(mStateValues[state] > mThresholds[state])
      mState = state;

   for (unsigned int i = 0; i < n; i++)
   {
      if(i == state)
         continue;
      
      mStateValues[i].dec(ellapsedTime);
   }
}

template <unsigned int n>
unsigned int BufferedState<n>::getValue() const
{
   return mState;
}

template <unsigned int n>
void BufferedState<n>::forceValue(int state)
{
   mState = state;

   for (int i = 0; i < n; i++)
   {
      mStateValues[i] = (i == state ? 1.0f : 0.0f);
   }
}
};};//namespace

#endif //_BUFFERED_N_STATE_H

---