625 lines
17 KiB
C++
625 lines
17 KiB
C++
|
// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
|
||
|
|
// Copyright (C) 2010 Winch Gate Property Limited
|
||
|
|
//
|
||
|
|
// This program is free software: you can redistribute it and/or modify
|
||
|
|
// it under the terms of the GNU Affero General Public License as
|
||
|
|
// published by the Free Software Foundation, either version 3 of the
|
||
|
|
// License, or (at your option) any later version.
|
||
|
|
//
|
||
|
|
// This program is distributed in the hope that it will be useful,
|
||
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
|
|
// GNU Affero General Public License for more details.
|
||
|
|
//
|
||
|
|
// You should have received a copy of the GNU Affero General Public License
|
||
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||
|
|
|
||
|
|
#include "std3d.h"
|
||
|
|
|
||
|
|
#include "nel/3d/animation_optimizer.h"
|
||
|
|
#include "nel/misc/mem_stream.h"
|
||
|
|
#include "nel/misc/vectord.h"
|
||
|
|
#include "nel/3d/track.h"
|
||
|
|
#include "nel/3d/track_keyframer.h"
|
||
|
|
#include "nel/3d/animation.h"
|
||
|
|
#include "nel/3d/track_sampled_quat.h"
|
||
|
|
#include "nel/3d/track_sampled_vector.h"
|
||
|
|
|
||
|
|
|
||
|
|
using namespace NLMISC;
|
||
|
|
using namespace std;
|
||
|
|
|
||
|
|
|
||
|
|
namespace NL3D
|
||
|
|
{
|
||
|
|
|
||
|
|
|
||
|
|
// ***************************************************************************
|
||
|
|
CAnimationOptimizer::CAnimationOptimizer()
|
||
|
|
{
|
||
|
|
_SampleFrameRate= 30;
|
||
|
|
_QuaternionThresholdLowPrec= 1.0 - 0.0001;
|
||
|
|
_QuaternionThresholdHighPrec= 1.0 - 0.000001;
|
||
|
|
_VectorThresholdLowPrec= 0.001;
|
||
|
|
_VectorThresholdHighPrec= 0.0001;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ***************************************************************************
|
||
|
|
void CAnimationOptimizer::setQuaternionThreshold(double lowPrecThre, double highPrecThre)
|
||
|
|
{
|
||
|
|
nlassert(lowPrecThre>=0);
|
||
|
|
nlassert(highPrecThre>=0);
|
||
|
|
_QuaternionThresholdLowPrec= 1.0 - lowPrecThre;
|
||
|
|
_QuaternionThresholdHighPrec= 1.0 - highPrecThre;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ***************************************************************************
|
||
|
|
void CAnimationOptimizer::setVectorThreshold(double lowPrecThre, double highPrecThre)
|
||
|
|
{
|
||
|
|
nlassert(lowPrecThre>=0);
|
||
|
|
nlassert(highPrecThre>=0);
|
||
|
|
_VectorThresholdLowPrec= lowPrecThre;
|
||
|
|
_VectorThresholdHighPrec= highPrecThre;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ***************************************************************************
|
||
|
|
void CAnimationOptimizer::setSampleFrameRate(float frameRate)
|
||
|
|
{
|
||
|
|
nlassert(frameRate>0);
|
||
|
|
_SampleFrameRate= frameRate;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ***************************************************************************
|
||
|
|
void CAnimationOptimizer::optimize(const CAnimation &animIn, CAnimation &animOut)
|
||
|
|
{
|
||
|
|
// 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);
|
||
|
|
}
|
||
|
|
|
||
|
|
// Parse all SSS shapes of the animation (important for preload of those shapes)
|
||
|
|
const vector<string> &shapes= animIn.getSSSShapes();
|
||
|
|
for(uint i=0;i<shapes.size();i++)
|
||
|
|
animOut.addSSSShape(shapes[i]);
|
||
|
|
|
||
|
|
// Set min animation length
|
||
|
|
animOut.setMinEndTime (animIn.getEndTime ());
|
||
|
|
nlassert (animOut.getEndTime() == animIn.getEndTime());
|
||
|
|
}
|
||
|
|
|
||
|
|
// ***************************************************************************
|
||
|
|
ITrack *CAnimationOptimizer::cloneTrack(const ITrack *trackIn)
|
||
|
|
{
|
||
|
|
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 CAnimationOptimizer::isTrackOptimisable(const ITrack *trackIn)
|
||
|
|
{
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ***************************************************************************
|
||
|
|
ITrack *CAnimationOptimizer::optimizeTrack(const ITrack *trackIn)
|
||
|
|
{
|
||
|
|
// 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??
|
||
|
|
//================
|
||
|
|
// eval the track only to get its value type!!
|
||
|
|
CAnimatedValueBlock avBlock;
|
||
|
|
const IAnimatedValue &valueType= ((ITrack*)trackIn)->eval(0, avBlock);
|
||
|
|
if( dynamic_cast<const CAnimatedValueQuat *>(&valueType) )
|
||
|
|
{
|
||
|
|
// 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->setDefaultValue(_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 *>(&valueType) )
|
||
|
|
{
|
||
|
|
// 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->setDefaultValue(_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);
|
||
|
|
}
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ***************************************************************************
|
||
|
|
// ***************************************************************************
|
||
|
|
// Quaternion optimisation
|
||
|
|
// ***************************************************************************
|
||
|
|
// ***************************************************************************
|
||
|
|
|
||
|
|
|
||
|
|
// ***************************************************************************
|
||
|
|
void CAnimationOptimizer::sampleQuatTrack(const ITrack *trackIn, float beginTime, float endTime, uint numSamples)
|
||
|
|
{
|
||
|
|
// 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;
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
// ***************************************************************************
|
||
|
|
bool CAnimationOptimizer::testConstantQuatTrack()
|
||
|
|
{
|
||
|
|
uint numSamples= (uint)_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;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ***************************************************************************
|
||
|
|
void CAnimationOptimizer::optimizeQuatTrack()
|
||
|
|
{
|
||
|
|
uint numSamples= (uint)_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;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ***************************************************************************
|
||
|
|
bool CAnimationOptimizer::nearlySameQuaternion(const CQuatD &quat0, const CQuatD &quat1)
|
||
|
|
{
|
||
|
|
// 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);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ***************************************************************************
|
||
|
|
// ***************************************************************************
|
||
|
|
// Vector optimisation
|
||
|
|
// ***************************************************************************
|
||
|
|
// ***************************************************************************
|
||
|
|
|
||
|
|
|
||
|
|
// ***************************************************************************
|
||
|
|
void CAnimationOptimizer::sampleVectorTrack(const ITrack *trackIn, float beginTime, float endTime, uint numSamples)
|
||
|
|
{
|
||
|
|
// 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;
|
||
|
|
}
|
||
|
|
|
||
|
|
}
|
||
|
|
|
||
|
|
// ***************************************************************************
|
||
|
|
bool CAnimationOptimizer::testConstantVectorTrack()
|
||
|
|
{
|
||
|
|
uint numSamples= (uint)_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;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ***************************************************************************
|
||
|
|
void CAnimationOptimizer::optimizeVectorTrack()
|
||
|
|
{
|
||
|
|
uint numSamples= (uint)_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;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ***************************************************************************
|
||
|
|
bool CAnimationOptimizer::nearlySameVector(const CVectorD &v0, const CVectorD &v1)
|
||
|
|
{
|
||
|
|
// 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);
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
// ***************************************************************************
|
||
|
|
// ***************************************************************************
|
||
|
|
// LowPrecisionTrack
|
||
|
|
// ***************************************************************************
|
||
|
|
// ***************************************************************************
|
||
|
|
|
||
|
|
|
||
|
|
// ***************************************************************************
|
||
|
|
void CAnimationOptimizer::addLowPrecisionTrack(const std::string &name)
|
||
|
|
{
|
||
|
|
_LowPrecTrackKeyName.push_back(name);
|
||
|
|
}
|
||
|
|
|
||
|
|
// ***************************************************************************
|
||
|
|
void CAnimationOptimizer::clearLowPrecisionTracks()
|
||
|
|
{
|
||
|
|
_LowPrecTrackKeyName.clear();
|
||
|
|
}
|
||
|
|
|
||
|
|
// ***************************************************************************
|
||
|
|
bool CAnimationOptimizer::isLowPrecisionTrack(const std::string &trackName)
|
||
|
|
{
|
||
|
|
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;
|
||
|
|
}
|
||
|
|
|
||
|
|
|
||
|
|
} // NL3D
|