scrawl
12 years ago
parent
de3c76a54b
commit
24f968623f
@ -1,424 +0,0 @@
|
||||
#ifndef _NIF_KEYLIST_H_
|
||||
#define _NIF_KEYLIST_H_
|
||||
|
||||
#include <cfloat>
|
||||
|
||||
namespace Nif
|
||||
{
|
||||
|
||||
template <typename iterator , typename predicate>
|
||||
void bubble_sort (iterator begin, iterator end, predicate const & in_order)
|
||||
{
|
||||
if (end > begin)
|
||||
{
|
||||
for (iterator i = begin; i != end - 1; ++i)
|
||||
{
|
||||
if (in_order (*(i+0), *(i+1)))
|
||||
continue;
|
||||
|
||||
for (iterator j = i; j >= begin; --j)
|
||||
{
|
||||
std::swap (*(j+0), *(j+1));
|
||||
|
||||
if (in_order (*(j+0), *(j+1)))
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template <typename value_type>
|
||||
value_type linear_interpolate (float amount, value_type prev, value_type next)
|
||||
{
|
||||
return prev + (next - prev) * amount;
|
||||
}
|
||||
|
||||
inline
|
||||
Ogre::Quaternion linear_interpolate (float amount, Ogre::Quaternion prev, Ogre::Quaternion next)
|
||||
{
|
||||
return Ogre::Quaternion::nlerp (amount, prev, next);
|
||||
}
|
||||
|
||||
template<typename value_type>
|
||||
struct KeyT {
|
||||
|
||||
static const size_t EncodedLength =
|
||||
NIFStream::handler <float>::EncodedLength +
|
||||
NIFStream::handler <value_type>::EncodedLength
|
||||
;
|
||||
|
||||
float mTime;
|
||||
value_type mValue;
|
||||
|
||||
void extract (NIFStream &nif)
|
||||
{
|
||||
nif.uncheckedRead (mTime);
|
||||
nif.uncheckedRead (mValue);
|
||||
}
|
||||
|
||||
static bool in_order (KeyT <value_type> const & l, KeyT <value_type> const & r)
|
||||
{
|
||||
return l.mTime < r.mTime;
|
||||
}
|
||||
|
||||
template <typename derived_type>
|
||||
struct NIFStream_handler
|
||||
{
|
||||
static const bool FixedLength = true;
|
||||
static const size_t EncodedLength = derived_type::EncodedLength;
|
||||
static const bool FileCompatibleLayout = true;
|
||||
|
||||
static void extract (NIFStream& Stream, KeyT <value_type> & Value)
|
||||
{
|
||||
static_cast <derived_type &> (Value).extract (Stream);
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct LinearKeyT : KeyT <T>
|
||||
{
|
||||
static T interpolate (LinearKeyT <T> * prev, LinearKeyT <T> * next, float amount)
|
||||
{
|
||||
return linear_interpolate (amount, prev->mValue, next->mValue);
|
||||
}
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct QuadraticKeyT : KeyT <T>
|
||||
{
|
||||
static const size_t EncodedLength =
|
||||
KeyT <T>::EncodedLength +
|
||||
NIFStream::handler <T>::EncodedLength * 2
|
||||
;
|
||||
|
||||
T mForwardValue;
|
||||
T mBackwardValue;
|
||||
|
||||
static T interpolate (QuadraticKeyT <T> * prev, QuadraticKeyT <T> * next, float amount)
|
||||
{
|
||||
return linear_interpolate (amount, prev->mValue, next->mValue);
|
||||
}
|
||||
|
||||
void extract (NIFStream &nif)
|
||||
{
|
||||
KeyT<T>::extract (nif);
|
||||
|
||||
nif.uncheckedRead (mForwardValue);
|
||||
nif.uncheckedRead (mBackwardValue);
|
||||
}
|
||||
};
|
||||
|
||||
template <typename T>
|
||||
struct TbcKeyT : KeyT <T>
|
||||
{
|
||||
static const size_t EncodedLength =
|
||||
KeyT <T>::EncodedLength +
|
||||
NIFStream::handler <float>::EncodedLength * 3
|
||||
;
|
||||
|
||||
float mTension;
|
||||
float mBias;
|
||||
float mContinuity;
|
||||
|
||||
static T interpolate (TbcKeyT <T> * prev, TbcKeyT <T> * next, float amount)
|
||||
{
|
||||
return linear_interpolate (amount, prev->mValue, next->mValue);
|
||||
}
|
||||
|
||||
void extract (NIFStream &nif)
|
||||
{
|
||||
KeyT<T>::extract (nif);
|
||||
|
||||
nif.uncheckedRead (mTension);
|
||||
nif.uncheckedRead (mBias);
|
||||
nif.uncheckedRead (mContinuity);
|
||||
}
|
||||
};
|
||||
|
||||
// register NIFStream extraction handlers for KeyT derivatives
|
||||
template <typename T> struct NIFStream::handler < LinearKeyT <T> > : KeyT <T>::template NIFStream_handler < LinearKeyT <T> > {};
|
||||
template <typename T> struct NIFStream::handler < QuadraticKeyT <T> > : KeyT <T>::template NIFStream_handler < QuadraticKeyT <T> > {};
|
||||
template <typename T> struct NIFStream::handler < TbcKeyT <T> > : KeyT <T>::template NIFStream_handler < TbcKeyT <T> > {};
|
||||
|
||||
struct Curve
|
||||
{
|
||||
static const int sLinearInterpolation = 1;
|
||||
static const int sQuadraticInterpolation = 2;
|
||||
static const int sTBCInterpolation = 3;
|
||||
};
|
||||
|
||||
template<typename value_type>
|
||||
struct CurveT : Curve {
|
||||
|
||||
typedef KeyT <value_type> BaseKey;
|
||||
typedef TbcKeyT <value_type> TcbKey;
|
||||
typedef LinearKeyT <value_type> LinearKey;
|
||||
typedef QuadraticKeyT <value_type> QuadraticKey;
|
||||
|
||||
union keys {
|
||||
LinearKey* Linear;
|
||||
QuadraticKey* Quadratic;
|
||||
TcbKey* Tcb;
|
||||
};
|
||||
|
||||
class interpolator;
|
||||
|
||||
int mInterpolationType;
|
||||
size_t mSize;
|
||||
keys mKeys;
|
||||
|
||||
value_type sample (float time) const;
|
||||
|
||||
KeyT <value_type> const * const & keyAtIndex (size_t Index) const
|
||||
{
|
||||
switch (mInterpolationType)
|
||||
{
|
||||
case sLinearInterpolation: return mKeys.Linear + Index;
|
||||
case sQuadraticInterpolation: return mKeys.Quadratic + Index;
|
||||
case sTBCInterpolation: return mKeys.Tcb + Index;
|
||||
}
|
||||
}
|
||||
|
||||
void read(NIFStream *nif, bool force=false)
|
||||
{
|
||||
size_t count = nif->getInt();
|
||||
|
||||
mSize = 0;
|
||||
|
||||
if(count > 0 || force)
|
||||
{
|
||||
mInterpolationType = nif->getInt();
|
||||
|
||||
assert (mInterpolationType >= sLinearInterpolation && mInterpolationType <= sTBCInterpolation);
|
||||
|
||||
if (count > 0)
|
||||
{
|
||||
if(mInterpolationType == sLinearInterpolation)
|
||||
read_keys (nif, mKeys.Linear, count);
|
||||
else if(mInterpolationType == sQuadraticInterpolation)
|
||||
read_keys (nif, mKeys.Quadratic, count);
|
||||
else if(mInterpolationType == sTBCInterpolation)
|
||||
read_keys (nif, mKeys.Tcb, count);
|
||||
else
|
||||
nif->file->warn("Unhandled interpolation type: "+Ogre::StringConverter::toString(mInterpolationType));
|
||||
}
|
||||
}
|
||||
else
|
||||
mInterpolationType = sLinearInterpolation;
|
||||
}
|
||||
|
||||
CurveT () { init (); }
|
||||
CurveT (CurveT <value_type> const & k) { init (k); }
|
||||
//CurveT (CurveT <value_type> && k) { init (); swap (std::move (k)); }
|
||||
~CurveT () { dest (); }
|
||||
|
||||
operator bool () const { return mSize > 0; }
|
||||
|
||||
//void operator = (CurveT<value_type> && k) { swap(k); }
|
||||
void operator = (CurveT<value_type> const & k) { dest (); init (k); }
|
||||
|
||||
void swap (CurveT<value_type> & k)
|
||||
{
|
||||
std::swap (mSize, k.mSize);
|
||||
std::swap (mInterpolationType, k.mInterpolationType);
|
||||
std::swap (mKeys, k.mKeys);
|
||||
}
|
||||
|
||||
private:
|
||||
|
||||
void init ()
|
||||
{
|
||||
mSize = 0;
|
||||
}
|
||||
|
||||
void init (CurveT<value_type> const & k)
|
||||
{
|
||||
mInterpolationType = k.mInterpolationType;
|
||||
switch (mInterpolationType)
|
||||
{
|
||||
default:
|
||||
case sLinearInterpolation:
|
||||
mKeys.Linear = new LinearKey [k.mSize];
|
||||
memcpy (mKeys.Linear, k.mKeys.Linear, sizeof (LinearKey) * k.mSize);
|
||||
mSize = k.mSize;
|
||||
break;
|
||||
case sQuadraticInterpolation:
|
||||
mKeys.Quadratic = new QuadraticKey [k.mSize];
|
||||
memcpy (mKeys.Quadratic, k.mKeys.Quadratic, sizeof (QuadraticKey) * k.mSize);
|
||||
mSize = k.mSize;
|
||||
break;
|
||||
case sTBCInterpolation:
|
||||
mKeys.Tcb = new TcbKey [k.mSize];
|
||||
memcpy (mKeys.Tcb, k.mKeys.Tcb, sizeof (TcbKey) * k.mSize);
|
||||
mSize = k.mSize;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
void dest ()
|
||||
{
|
||||
if (mSize > 0)
|
||||
{
|
||||
switch (mInterpolationType)
|
||||
{
|
||||
case sLinearInterpolation: delete mKeys.Linear; break;
|
||||
case sQuadraticInterpolation: delete mKeys.Quadratic; break;
|
||||
case sTBCInterpolation: delete mKeys.Tcb; break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
template <typename T>
|
||||
void read_keys (NIFStream *nif, T * & store, size_t count)
|
||||
{
|
||||
store = new T [count];
|
||||
|
||||
mSize = count;
|
||||
|
||||
nif->getArray (store, count);
|
||||
|
||||
//NOTE: Is this really necessary? It seems reasonable to assume that
|
||||
// animation data is already sorted by time...
|
||||
// verified no out of order frames in GOTY edition
|
||||
bubble_sort (store, store+count, T::in_order);
|
||||
}
|
||||
};
|
||||
|
||||
template<typename value_type>
|
||||
class CurveT<value_type>::interpolator
|
||||
{
|
||||
template <typename key_type>
|
||||
struct impl
|
||||
{
|
||||
key_type *Cur, *End;
|
||||
|
||||
void init (key_type * Beg, size_t Len)
|
||||
{
|
||||
if (Len > 0)
|
||||
{
|
||||
Cur = Beg;
|
||||
End = Beg + Len - 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
Cur = End = NULL;
|
||||
}
|
||||
}
|
||||
|
||||
bool hasData () const
|
||||
{
|
||||
return Cur && Cur <= End;
|
||||
}
|
||||
|
||||
value_type valueAt (float time)
|
||||
{
|
||||
while ((Cur < End) && (time >= Cur [1].mTime))
|
||||
++Cur;
|
||||
|
||||
if (Cur < End)
|
||||
{
|
||||
if (time > Cur->mTime)
|
||||
{
|
||||
key_type * Nxt = Cur + 1;
|
||||
|
||||
float offset = time - Cur->mTime;
|
||||
float length = Nxt->mTime - Cur->mTime;
|
||||
|
||||
return key_type::interpolate (Cur, Nxt, offset / length);
|
||||
}
|
||||
else
|
||||
return Cur->mValue;
|
||||
}
|
||||
else
|
||||
return End->mValue;
|
||||
}
|
||||
|
||||
float curTime () const
|
||||
{
|
||||
return (Cur != NULL) ? Cur->Time : FLT_MIN;
|
||||
}
|
||||
|
||||
float nextTime () const
|
||||
{
|
||||
return Cur < End ? (Cur + 1)->mTime : FLT_MAX;
|
||||
}
|
||||
};
|
||||
|
||||
public:
|
||||
|
||||
int mInterpolationType;
|
||||
union {
|
||||
impl <LinearKey> Linear;
|
||||
impl <QuadraticKey> Quadratic;
|
||||
impl <TcbKey> Tcb;
|
||||
};
|
||||
|
||||
interpolator (CurveT <value_type> const & Curve)
|
||||
{
|
||||
mInterpolationType = Curve.mInterpolationType;
|
||||
|
||||
switch (mInterpolationType)
|
||||
{
|
||||
default:
|
||||
case Curve::sLinearInterpolation: Linear .init (Curve.mKeys.Linear, Curve.mSize); break;
|
||||
case Curve::sQuadraticInterpolation: Quadratic.init (Curve.mKeys.Quadratic, Curve.mSize); break;
|
||||
case Curve::sTBCInterpolation: Tcb .init (Curve.mKeys.Tcb, Curve.mSize); break;
|
||||
}
|
||||
}
|
||||
|
||||
// return true if there is any value(s) in this curve
|
||||
float hasData () const
|
||||
{
|
||||
switch (mInterpolationType)
|
||||
{
|
||||
default:
|
||||
case Curve::sLinearInterpolation: return Linear .hasData ();
|
||||
case Curve::sQuadraticInterpolation: return Quadratic.hasData ();
|
||||
case Curve::sTBCInterpolation: return Tcb .hasData ();
|
||||
}
|
||||
}
|
||||
|
||||
// return the timestamp of the next key-frame, or FLT_MAX if
|
||||
// there are no more key-frames, valid if hasData returns false
|
||||
float nextTime () const
|
||||
{
|
||||
switch (mInterpolationType)
|
||||
{
|
||||
default:
|
||||
case Curve::sLinearInterpolation: return Linear .nextTime ();
|
||||
case Curve::sQuadraticInterpolation: return Quadratic.nextTime ();
|
||||
case Curve::sTBCInterpolation: return Tcb .nextTime ();
|
||||
}
|
||||
}
|
||||
|
||||
// return the value of the curve at the specified time
|
||||
// the passed in time should never exceed the result of
|
||||
// nextTime, not valid if hasData returns false
|
||||
value_type valueAt (float time)
|
||||
{
|
||||
switch (mInterpolationType)
|
||||
{
|
||||
default:
|
||||
case Curve::sLinearInterpolation: return Linear .valueAt (time);
|
||||
case Curve::sQuadraticInterpolation: return Quadratic.valueAt (time);
|
||||
case Curve::sTBCInterpolation: return Tcb .valueAt (time);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
template<typename value_type>
|
||||
value_type CurveT<value_type>::sample (float time) const
|
||||
{
|
||||
interpolator i (*this);
|
||||
return i.valueAt (time);
|
||||
}
|
||||
|
||||
typedef CurveT<float> FloatCurve;
|
||||
typedef CurveT<Ogre::Vector3> Vector3Curve;
|
||||
typedef CurveT<Ogre::Vector4> Vector4Curve;
|
||||
typedef CurveT<Ogre::Quaternion> QuaternionCurve;
|
||||
|
||||
}
|
||||
|
||||
#endif
|
||||
Loading…
Reference in New Issue