NL3D::CAnimationOptimizer Class Reference

#include <animation_optimizer.h>

---

Detailed Description

Purpose of this class is to optimize for memory and speed a CAnimation. Quaternion tracks are optimized. They are transformed to CTrackSampledQuat or CTrackDefaultQuat. Vector tracks are optimized. They are transformed to CTrackSampledVector or CTrackDefaultVector.

Author:

Lionel Berenguier

Nevrax France

Date:

2002

Definition at line 54 of file animation_optimizer.h.

Public Member Functions
void	addLowPrecisionTrack (const std::string &name)
	CAnimationOptimizer ()
	Constructor.
void	clearLowPrecisionTracks ()
	see addLowPrecisionTrack. This clear the array.
void	optimize (const CAnimation &animIn, CAnimation &animOut)
void	setQuaternionThreshold (double lowPrecThre, double highPrecThre)
void	setSampleFrameRate (float frameRate)
void	setVectorThreshold (double lowPrecThre, double highPrecThre)
Private Member Functions
ITrack *	cloneTrack (const ITrack *trackIn)
bool	isLowPrecisionTrack (const std::string &trackName)
bool	isTrackOptimisable (const ITrack *trackIn)
ITrack *	optimizeTrack (const ITrack *trackIn)
bool	nearlySameQuaternion (const CQuatD &quat0, const CQuatD &quat1)
void	optimizeQuatTrack ()
void	sampleQuatTrack (const ITrack *trackIn, float beginTime, float endTime, uint numSamples)
bool	testConstantQuatTrack ()
bool	nearlySameVector (const CVectorD &v0, const CVectorD &v1)
void	optimizeVectorTrack ()
void	sampleVectorTrack (const ITrack *trackIn, float beginTime, float endTime, uint numSamples)
bool	testConstantVectorTrack ()
Private Attributes
std::vector< std::string >	_LowPrecTrackKeyName
double	_QuaternionThreshold
double	_QuaternionThresholdHighPrec
double	_QuaternionThresholdLowPrec
std::vector< CQuat >	_QuatKeyList
float	_SampleFrameRate
std::vector< uint16 >	_TimeList
std::vector< CVector >	_VectorKeyList
double	_VectorThreshold
double	_VectorThresholdHighPrec
double	_VectorThresholdLowPrec

---

Constructor & Destructor Documentation

NL3D::CAnimationOptimizer::CAnimationOptimizer (   )

Constructor. Definition at line 47 of file animation_optimizer.cpp. References _QuaternionThresholdHighPrec, _QuaternionThresholdLowPrec, _SampleFrameRate, _VectorThresholdHighPrec, and _VectorThresholdLowPrec. { _SampleFrameRate= 30; _QuaternionThresholdLowPrec= 1.0 - 0.0001; _QuaternionThresholdHighPrec= 1.0 - 0.000001; _VectorThresholdLowPrec= 0.001; _VectorThresholdHighPrec= 0.0001; }

---

Member Function Documentation

void NL3D::CAnimationOptimizer::addLowPrecisionTrack (  const std::string &  name  )

see setQuaternionThreshold(). Any track which contains this name will be considered as a Low precision track. Default setup is empty, so all track are "high precision" track. A good setup is for example addLowPrecisionTrack("Finger") and addLowPrecisionTrack("Ponytail") Warning: case sensitive Definition at line 599 of file animation_optimizer.cpp. References _LowPrecTrackKeyName. { _LowPrecTrackKeyName.push_back(name); }

void NL3D::CAnimationOptimizer::clearLowPrecisionTracks (   )

see addLowPrecisionTrack. This clear the array. Definition at line 605 of file animation_optimizer.cpp. References _LowPrecTrackKeyName. { _LowPrecTrackKeyName.clear(); }

ITrack * NL3D::CAnimationOptimizer::cloneTrack (  const ITrack *  trackIn  )  [private]

Definition at line 138 of file animation_optimizer.cpp. References NLMISC::CMemStream::invert(), and NLMISC::IStream::serialPolyPtr(). Referenced by optimize(), and optimizeTrack(). { CMemStream memStream; // write to the stream. ITrack *trackInSerial= const_cast<ITrack*>(trackIn); memStream.serialPolyPtr(trackInSerial); // read from the stream. memStream.invert(); ITrack *ret= NULL; memStream.serialPolyPtr(ret); return ret; }

bool NL3D::CAnimationOptimizer::isLowPrecisionTrack (  const std::string &  trackName  )  [private]

Definition at line 611 of file animation_optimizer.cpp. References _LowPrecTrackKeyName, and uint. Referenced by optimize(). { for(uint i=0; i<_LowPrecTrackKeyName.size(); i++) { // if find a substr of the key, it is a low prec track if( trackName.find(_LowPrecTrackKeyName[i]) != string::npos ) return true; } // no key found return false; }

bool NL3D::CAnimationOptimizer::isTrackOptimisable (  const ITrack *  trackIn  )  [private]

Definition at line 156 of file animation_optimizer.cpp. References nlassert. Referenced by optimize(). { nlassert(trackIn); // If the track is a Linear, Bezier or a TCB track, suppose we can optimize it. Constant may not be interressant.... if( dynamic_cast<const CTrackKeyFramerTCBQuat*>(trackIn) || dynamic_cast<const CTrackKeyFramerBezierQuat*>(trackIn) || dynamic_cast<const CTrackKeyFramerLinearQuat*>(trackIn) ) return true; // If the track is a Linear, Bezier or a TCB track, suppose we can optimize it. Constant may not be interressant.... if( dynamic_cast<const CTrackKeyFramerTCBVector*>(trackIn) || dynamic_cast<const CTrackKeyFramerBezierVector*>(trackIn) || dynamic_cast<const CTrackKeyFramerLinearVector*>(trackIn) ) return true; return false; }

bool NL3D::CAnimationOptimizer::nearlySameQuaternion (  const CQuatD &  quat0, const CQuatD &  quat1 )  [private]

return true if suppose same quaternion. NB: quaternion must be normalized. NB: test if quat1==quat0 or quat1==-quat0 of course. Definition at line 423 of file animation_optimizer.cpp. References _QuaternionThreshold, NLMISC::CQuatT< double >::conjugate(), and NLMISC::CQuatT< double >::w. Referenced by optimizeQuatTrack(), and testConstantQuatTrack(). { // true if exactly same, or exactly inverse if(quat0==quat1 || quat0==-quat1) return true; // Else compute the rotation to go from qRef to q. Use double for better presion. CQuatD quatDif; quatDif= quat1 * quat0.conjugate(); // inverse the quaternion if necessary. ie make closest to the identity quaternion. if(quatDif.w<0) quatDif= -quatDif; // compare "angle threshold" return (quatDif.w >= _QuaternionThreshold); }

bool NL3D::CAnimationOptimizer::nearlySameVector (  const CVectorD &  v0, const CVectorD &  v1 )  [private]

return true if suppose same vector. Definition at line 576 of file animation_optimizer.cpp. References _VectorThreshold, and NLMISC::CVectorD::norm(). Referenced by optimizeVectorTrack(), and testConstantVectorTrack(). { // true if exactly same if(v0==v1) return true; // Else compute the dif, use double for better precision CVectorD vDif; vDif= v1-v0; // compare norm return (vDif.norm() <= _VectorThreshold); }

void NL3D::CAnimationOptimizer::optimize (  const CAnimation &  animIn, CAnimation &  animOut )

optimize an animation animOut is the same as animIn, but optimized. If a track can't be optimized, it is just duplicated in animOut. Definition at line 86 of file animation_optimizer.cpp. References _QuaternionThreshold, _QuaternionThresholdHighPrec, _QuaternionThresholdLowPrec, _VectorThreshold, _VectorThresholdHighPrec, _VectorThresholdLowPrec, NL3D::CAnimation::addTrack(), cloneTrack(), NL3D::CAnimation::getEndTime(), NL3D::CAnimation::getIdTrackByName(), NL3D::CAnimation::getTrack(), NL3D::CAnimation::getTrackNames(), isLowPrecisionTrack(), isTrackOptimisable(), nlassert, optimizeTrack(), NL3D::CAnimation::setMinEndTime(), and uint. { // reset animOut contReset(animOut); // Parse all tracks of the animation. set<string> setString; animIn.getTrackNames (setString); set<string>::iterator it; for(it=setString.begin();it!=setString.end();it++) { const string &trackName= *it; uint trackId= animIn.getIdTrackByName(trackName); nlassert(trackId!=CAnimation::NotFound); const ITrack *track= animIn.getTrack(trackId); // If the track is optimisable. ITrack *newTrack; if(isTrackOptimisable(track)) { // choose the threshold according to precision wanted if( isLowPrecisionTrack(trackName) ) { _QuaternionThreshold= _QuaternionThresholdLowPrec; _VectorThreshold= _VectorThresholdLowPrec; } else { _QuaternionThreshold= _QuaternionThresholdHighPrec; _VectorThreshold= _VectorThresholdHighPrec; } // optimize it. newTrack= optimizeTrack(track); } else { // just clone it. newTrack= cloneTrack(track); } // Add it to the animation animOut.addTrack(trackName, newTrack); } // Set min animation length animOut.setMinEndTime (animIn.getEndTime ()); nlassert (animOut.getEndTime() == animIn.getEndTime()); }

void NL3D::CAnimationOptimizer::optimizeQuatTrack (   )  [private]

optimze the current track Definition at line 341 of file animation_optimizer.cpp. References _QuatKeyList, _TimeList, nearlySameQuaternion(), nlassert, t, and uint. Referenced by optimizeTrack(). { uint numSamples= _QuatKeyList.size(); nlassert(numSamples>0); // <=2 key? => no opt possible.. if(numSamples<=2) return; // prepare dest opt std::vector<uint16> optTimeList; std::vector<CQuat> optKeyList; optTimeList.reserve(numSamples); optKeyList.reserve(numSamples); // Add the first key. optTimeList.push_back(_TimeList[0]); optKeyList.push_back(_QuatKeyList[0]); double timeRef= _TimeList[0]; CQuatD quatRef= _QuatKeyList[0]; // For all keys, but the first and the last, test if can remove them. for(uint i=1; i<numSamples-1; i++) { CQuatD quatCur= _QuatKeyList[i]; CQuatD quatNext= _QuatKeyList[i+1]; double timeCur= _TimeList[i]; double timeNext= _TimeList[i+1]; // must add the key? bool mustAdd= false; // If the Delta time are too big, abort (CTrackSampledQuat limitation) if(timeNext-timeRef>255) { mustAdd= true; } // If the next quaternion or the current quaternion are not on same hemisphere than ref, abort. else if( CQuatD::dotProduct(quatCur, quatRef)<0 || CQuatD::dotProduct(quatNext, quatRef)<0 ) { mustAdd= true; } // else, test interpolation else { // If the 3 quats are nearly equals, it is ok (avoid interpolation) if( nearlySameQuaternion(quatRef, quatCur) && nearlySameQuaternion(quatRef, quatNext) ) mustAdd= false; else { // interpolate. CQuatD quatInterpolated; double t= (timeCur-timeRef)/(timeNext/timeRef); quatInterpolated= CQuatD::slerp(quatRef, quatNext, (float)t); // test if cur and interpolate are equal. if( !nearlySameQuaternion(quatCur, quatInterpolated) ) mustAdd= true; } } // If must add the key to the optimized track. if(mustAdd) { optTimeList.push_back(_TimeList[i]); optKeyList.push_back(_QuatKeyList[i]); timeRef= _TimeList[i]; quatRef= _QuatKeyList[i]; } } // Add the last key. optTimeList.push_back(_TimeList[numSamples-1]); optKeyList.push_back(_QuatKeyList[numSamples-1]); // copy the optimized track to the main one. _TimeList= optTimeList; _QuatKeyList= optKeyList; }

ITrack * NL3D::CAnimationOptimizer::optimizeTrack (  const ITrack *  trackIn  )  [private]

Definition at line 177 of file animation_optimizer.cpp. References _QuatKeyList, _SampleFrameRate, _TimeList, _VectorKeyList, NL3D::CTrackSampledVector::build(), NL3D::CTrackSampledQuat::build(), cloneTrack(), NL3D::UTrack::getBeginTime(), NL3D::UTrack::getEndTime(), NL3D::ITrack::getLoopMode(), NL3D::ITrack::getValue(), nlassert, nlstop, optimizeQuatTrack(), optimizeVectorTrack(), sampleQuatTrack(), sampleVectorTrack(), NL3D::CTrackSampledCommon::setLoopMode(), NL3D::CTrackDefaultBlendable< CVector >::setValue(), NL3D::CTrackDefaultBlendable< CQuat >::setValue(), testConstantQuatTrack(), testConstantVectorTrack(), and uint. Referenced by optimize(). { // Get track param. float beginTime= trackIn->getBeginTime(); float endTime= trackIn->getEndTime(); nlassert(endTime>=beginTime); // Get num Sample uint numSamples= (uint)ceil( (endTime-beginTime)*_SampleFrameRate); numSamples= max(1U, numSamples); nlassert(numSamples<65535); // Optimize Quaternion track?? //================ if( dynamic_cast<const CAnimatedValueQuat *>(&trackIn->getValue()) ) { // sample the animation. Store result in _TimeList/_QuatKeyList sampleQuatTrack(trackIn, beginTime, endTime, numSamples); // check if the sampled track can be reduced to a TrackDefaultQuat. Test _QuatKeyList. if( testConstantQuatTrack() ) { // create a default Track Quat. CTrackDefaultQuat *trackDefault= new CTrackDefaultQuat; // setup the uniform value. trackDefault->setValue(_QuatKeyList[0]); // return the result. return trackDefault; } // else optimize the sampled animation, and build. else { // optimize. optimizeQuatTrack(); // Create a sampled quaternion track CTrackSampledQuat *trackSQ= new CTrackSampledQuat; // Copy loop from track. trackSQ->setLoopMode(trackIn->getLoopMode()); // Build it. trackSQ->build(_TimeList, _QuatKeyList, beginTime, endTime); // return result. return trackSQ; } } // Optimize Position track?? //================ else if( dynamic_cast<const CAnimatedValueVector *>(&trackIn->getValue()) ) { // sample the animation. Store result in _TimeList/_VectorKeyList sampleVectorTrack(trackIn, beginTime, endTime, numSamples); // check if the sampled track can be reduced to a TrackDefaultVector. Test _VectorKeyList. if( testConstantVectorTrack() ) { // create a default Track Vector. CTrackDefaultVector *trackDefault= new CTrackDefaultVector; // setup the uniform value. trackDefault->setValue(_VectorKeyList[0]); // return the result. return trackDefault; } // else optimize the sampled animation, and build. else { // optimize. optimizeVectorTrack(); // Create a sampled Vector track CTrackSampledVector *trackSV= new CTrackSampledVector; // Copy loop from track. trackSV->setLoopMode(trackIn->getLoopMode()); // Build it. trackSV->build(_TimeList, _VectorKeyList, beginTime, endTime); // return result. return trackSV; } } else { // Must be a quaternion track or vector track for now. nlstop; // Avoid warning. return cloneTrack(trackIn); } }

void NL3D::CAnimationOptimizer::optimizeVectorTrack (   )  [private]

optimze the current track Definition at line 499 of file animation_optimizer.cpp. References _TimeList, _VectorKeyList, nearlySameVector(), nlassert, t, and uint. Referenced by optimizeTrack(). { uint numSamples= _VectorKeyList.size(); nlassert(numSamples>0); // <=2 key? => no opt possible.. if(numSamples<=2) return; // prepare dest opt std::vector<uint16> optTimeList; std::vector<CVector> optKeyList; optTimeList.reserve(numSamples); optKeyList.reserve(numSamples); // Add the first key. optTimeList.push_back(_TimeList[0]); optKeyList.push_back(_VectorKeyList[0]); double timeRef= _TimeList[0]; CVectorD vectorRef= _VectorKeyList[0]; // For all keys, but the first and the last, test if can remove them. for(uint i=1; i<numSamples-1; i++) { CVectorD vectorCur= _VectorKeyList[i]; CVectorD vectorNext= _VectorKeyList[i+1]; double timeCur= _TimeList[i]; double timeNext= _TimeList[i+1]; // must add the key? bool mustAdd= false; // If the Delta time are too big, abort (CTrackSampledVector limitation) if(timeNext-timeRef>255) { mustAdd= true; } // else, test interpolation else { // If the 3 Vectors are nearly equals, it is ok (avoid interpolation) if( nearlySameVector(vectorRef, vectorCur) && nearlySameVector(vectorRef, vectorNext) ) mustAdd= false; else { // interpolate. CVectorD vectorInterpolated; double t= (timeCur-timeRef)/(timeNext/timeRef); vectorInterpolated= vectorRef*(1-t) + vectorNext*t; // test if cur and interpolate are equal. if( !nearlySameVector(vectorCur, vectorInterpolated) ) mustAdd= true; } } // If must add the key to the optimized track. if(mustAdd) { optTimeList.push_back(_TimeList[i]); optKeyList.push_back(_VectorKeyList[i]); timeRef= _TimeList[i]; vectorRef= _VectorKeyList[i]; } } // Add the last key. optTimeList.push_back(_TimeList[numSamples-1]); optKeyList.push_back(_VectorKeyList[numSamples-1]); // copy the optimized track to the main one. _TimeList= optTimeList; _VectorKeyList= optKeyList; }

void NL3D::CAnimationOptimizer::sampleQuatTrack (  const ITrack *  trackIn, float  beginTime, float  endTime, uint  numSamples )  [private]

sample the track from beginTime to endTime, sample to numSamples, such that key[0].Time==beginTime and key[numSamples-1].Time==endTime. NB: quaternion are normalized, and are makeClosest()-ed from sample to the next. Definition at line 282 of file animation_optimizer.cpp. References _QuatKeyList, _TimeList, NLMISC::CQuatT< float >::makeClosest(), NLMISC::CQuatT< float >::normalize(), t, and uint. Referenced by optimizeTrack(). { // resize tmp samples _TimeList.resize(numSamples); _QuatKeyList.resize(numSamples); // Sample the animation. float t= beginTime; float dt= 0; if(numSamples>1) dt= (endTime-beginTime)/(numSamples-1); for(uint i=0;i<numSamples; i++, t+=dt) { CQuat quat; // make exact endTime match (avoid precision problem) if(i==numSamples-1) t= endTime; // evaluate the track const_cast<ITrack*>(trackIn)->interpolate(t, quat); // normalize this quaternion quat.normalize(); // force on same hemisphere according to precedent frame. if(i>0) { quat.makeClosest(_QuatKeyList[i-1]); } // store time and key. _TimeList[i]= i; _QuatKeyList[i]= quat; } }

void NL3D::CAnimationOptimizer::sampleVectorTrack (  const ITrack *  trackIn, float  beginTime, float  endTime, uint  numSamples )  [private]

sample the track from beginTime to endTime, sample to numSamples, such that key[0].Time==beginTime and key[numSamples-1].Time==endTime. Definition at line 449 of file animation_optimizer.cpp. References _TimeList, _VectorKeyList, t, and uint. Referenced by optimizeTrack(). { // resize tmp samples _TimeList.resize(numSamples); _VectorKeyList.resize(numSamples); // Sample the animation. float t= beginTime; float dt= 0; if(numSamples>1) dt= (endTime-beginTime)/(numSamples-1); for(uint i=0;i<numSamples; i++, t+=dt) { CVector vector; // make exact endTime match (avoid precision problem) if(i==numSamples-1) t= endTime; // evaluate the track const_cast<ITrack*>(trackIn)->interpolate(t, vector); // store time and key. _TimeList[i]= i; _VectorKeyList[i]= vector; } }

void NL3D::CAnimationOptimizer::setQuaternionThreshold (  double  lowPrecThre, double  highPrecThre )

Set the Quaternion Error Thresholds. must be>=0. Default is 0.0001 and 0.000001. Above this value, 2 quaternions are said different. NB: comparing 2 quaternions is made by multiplying the one with the inverse of the other. the W component is then tested and must be >1-threshold (modulo sign) to conclude to equality. Since quat.W= cos(angle/2), you can deduce the angle threshold with angleThre= acos(1-thre)*2 Give 2 value, one For Low precision and High precision. Default setup use high precision. Use addLowPrecisionTrack() to drive low precision tracks. Definition at line 58 of file animation_optimizer.cpp. References _QuaternionThresholdHighPrec, _QuaternionThresholdLowPrec, and nlassert. { nlassert(lowPrecThre>=0); nlassert(highPrecThre>=0); _QuaternionThresholdLowPrec= 1.0 - lowPrecThre; _QuaternionThresholdHighPrec= 1.0 - highPrecThre; }

void NL3D::CAnimationOptimizer::setSampleFrameRate (  float  frameRate  )

Set the Sample Frame Rate (>0) Default is 30 fps. NB: final numSamples must be <65535, else assert at optimize() time. Definition at line 78 of file animation_optimizer.cpp. References _SampleFrameRate, and nlassert. { nlassert(frameRate>0); _SampleFrameRate= frameRate; }

void NL3D::CAnimationOptimizer::setVectorThreshold (  double  lowPrecThre, double  highPrecThre )

Same principle as for setQuaternionThreshold(), but for vector tracks (positions/scale). Default is 0.001 and 0.0001. Above this value, 2 vectors are said different. NB: comparing 2 vectors is made by geting the norm of the difference Give 2 value, one For Low precision and High precision. Default setup use high precision. Use addLowPrecisionTrack() to drive low precision tracks. Definition at line 68 of file animation_optimizer.cpp. References _VectorThresholdHighPrec, _VectorThresholdLowPrec, and nlassert. { nlassert(lowPrecThre>=0); nlassert(highPrecThre>=0); _VectorThresholdLowPrec= lowPrecThre; _VectorThresholdHighPrec= highPrecThre; }

bool NL3D::CAnimationOptimizer::testConstantQuatTrack (   )  [private]

Test if the current track is constant (ie always same quaternion value) NB: test if q==qRef or q==-qRef of course. Definition at line 321 of file animation_optimizer.cpp. References _QuatKeyList, nearlySameQuaternion(), nlassert, and uint. Referenced by optimizeTrack(). { uint numSamples= _QuatKeyList.size(); nlassert(numSamples>0); // Get the first sample as the reference quaternion, and test others from this one. CQuat quatRef= _QuatKeyList[0]; for(uint i=0;i<numSamples;i++) { // All values must be nearly equal to the reference quaternion. if(!nearlySameQuaternion(quatRef, _QuatKeyList[i])) return false; } // ok. return true; }

bool NL3D::CAnimationOptimizer::testConstantVectorTrack (   )  [private]

Test if the current track is constant (ie always same Vector value) Definition at line 479 of file animation_optimizer.cpp. References _VectorKeyList, nearlySameVector(), nlassert, and uint. Referenced by optimizeTrack(). { uint numSamples= _VectorKeyList.size(); nlassert(numSamples>0); // Get the first sample as the reference Vectorer, and test others from this one. CVector vectorRef= _VectorKeyList[0]; for(uint i=0;i<numSamples;i++) { // All values must be nearly equal to the reference vector. if(!nearlySameVector(vectorRef, _VectorKeyList[i])) return false; } // ok. return true; }

---

Field Documentation

std::vector<std::string> NL3D::CAnimationOptimizer::_LowPrecTrackKeyName [private]

Definition at line 116 of file animation_optimizer.h. Referenced by addLowPrecisionTrack(), clearLowPrecisionTracks(), and isLowPrecisionTrack().

double NL3D::CAnimationOptimizer::_QuaternionThreshold [private]

Definition at line 109 of file animation_optimizer.h. Referenced by nearlySameQuaternion(), and optimize().

double NL3D::CAnimationOptimizer::_QuaternionThresholdHighPrec [private]

Definition at line 108 of file animation_optimizer.h. Referenced by CAnimationOptimizer(), optimize(), and setQuaternionThreshold().

double NL3D::CAnimationOptimizer::_QuaternionThresholdLowPrec [private]

Definition at line 107 of file animation_optimizer.h. Referenced by CAnimationOptimizer(), optimize(), and setQuaternionThreshold().

std::vector<CQuat> NL3D::CAnimationOptimizer::_QuatKeyList [private]

Definition at line 120 of file animation_optimizer.h. Referenced by optimizeQuatTrack(), optimizeTrack(), sampleQuatTrack(), and testConstantQuatTrack().

float NL3D::CAnimationOptimizer::_SampleFrameRate [private]

Definition at line 106 of file animation_optimizer.h. Referenced by CAnimationOptimizer(), optimizeTrack(), and setSampleFrameRate().

std::vector<uint16> NL3D::CAnimationOptimizer::_TimeList [private]

Definition at line 119 of file animation_optimizer.h. Referenced by optimizeQuatTrack(), optimizeTrack(), optimizeVectorTrack(), sampleQuatTrack(), and sampleVectorTrack().

std::vector<CVector> NL3D::CAnimationOptimizer::_VectorKeyList [private]

Definition at line 123 of file animation_optimizer.h. Referenced by optimizeTrack(), optimizeVectorTrack(), sampleVectorTrack(), and testConstantVectorTrack().

double NL3D::CAnimationOptimizer::_VectorThreshold [private]

Definition at line 112 of file animation_optimizer.h. Referenced by nearlySameVector(), and optimize().

double NL3D::CAnimationOptimizer::_VectorThresholdHighPrec [private]

Definition at line 111 of file animation_optimizer.h. Referenced by CAnimationOptimizer(), optimize(), and setVectorThreshold().

double NL3D::CAnimationOptimizer::_VectorThresholdLowPrec [private]

Definition at line 110 of file animation_optimizer.h. Referenced by CAnimationOptimizer(), optimize(), and setVectorThreshold().

---

The documentation for this class was generated from the following files:

• animation_optimizer.h
• animation_optimizer.cpp

---