NeL: NL3D::CTrackSampledVector class Reference

00081 {
+00082         nlassert( endTime>beginTime || (beginTime==endTime && keyList.size()<=1) );
+00083         nlassert( keyList.size()==timeList.size() );
+00084         uint i;
+00085 
+00086         // reset.
+00087         uint    numKeys= keyList.size();
+00088         _Keys.clear();
+00089         _TimeBlocks.clear();
+00090 
+00091         // Build Common time information
+00092         CTrackSampledCommon::buildCommon(timeList, beginTime, endTime);
+00093 
+00094 
+00095         // Compute All Key values.
+00096         //===================
+00097         _Keys.resize(numKeys);
+00098         for(i=0; i<numKeys;i++)
+00099         {
+00100                 // no compression for now
+00101                 _Keys[i]= keyList[i];
+00102         }
+00103 
+00104 }
+

00107 {
+00108         nlassert( endTime>beginTime || (beginTime==endTime && timeList.size()<=1) );
+00109         uint i;
+00110 
+00111         // reset.
+00112         uint    numKeys= timeList.size();
+00113         _TimeBlocks.clear();
+00114 
+00115         // Special case of 0 or 1 key.
+00116         //===================
+00117         if(numKeys<=1)
+00118         {
+00119                 _BeginTime= beginTime;
+00120                 _EndTime= endTime;
+00121                 _TotalRange= 0;
+00122                 _OOTotalRange= 0;
+00123                 _DeltaTime= 0;
+00124                 _OODeltaTime= 0;
+00125                 if(numKeys==1)
+00126                 {
+00127                         _TimeBlocks.resize(1);
+00128                         _TimeBlocks[0].TimeOffset= 0;
+00129                         _TimeBlocks[0].Times.resize(1);
+00130                         _TimeBlocks[0].Times[0]= 0;
+00131                 }
+00132 
+00133                 return;
+00134         }
+00135 
+00136         // Compute All Time blocks.
+00137         //===================
+00138         sint32          lastBlockFrame= -1000000;
+00139         nlassert(timeList[0] == 0);
+00140         // Header info for creating timeBlocks
+00141         vector<uint>    timeBlockKeyId;
+00142         vector<uint>    timeBlockNumKeys;
+00143 
+00144         // compute how many time block we need.
+00145         for(i=0; i<numKeys; i++)
+00146         {
+00147                 // verify growing order, and time difference.
+00148                 if(i>0)
+00149                 {
+00150                         nlassert(timeList[i]>timeList[i-1]);
+00151                         nlassert(timeList[i]-timeList[i-1] <= 255 );
+00152                 }
+00153                 // If the current frame is to far from the last TimeBlock frame (or if 1st timeBlock), must create a new timeBlock
+00154                 if(timeList[i]-lastBlockFrame>255)
+00155                 {
+00156                         // create a new timeblock
+00157                         timeBlockKeyId.push_back(i);
+00158                         // Add this key to this new time Block (numKey == 1).
+00159                         timeBlockNumKeys.push_back(1);
+00160                         lastBlockFrame= timeList[i];
+00161                 }
+00162                 else
+00163                 {
+00164                         // Add this key to the timeBlock.
+00165                         timeBlockNumKeys[timeBlockNumKeys.size()-1]++;
+00166                 }
+00167         }
+00168 
+00169         // Build the timeBlocks.
+00170         _TimeBlocks.resize(timeBlockKeyId.size());
+00171         for(i=0; i<timeBlockKeyId.size(); i++)
+00172         {
+00173                 CTimeBlock      &timeBlock= _TimeBlocks[i];
+00174                 uint            firstKeyId= timeBlockKeyId[i];
+00175                 uint            numKeys= timeBlockNumKeys[i];
+00176                 // compute the offset time and key
+00177                 timeBlock.KeyOffset= firstKeyId;
+00178                 timeBlock.TimeOffset= timeList[firstKeyId];
+00179                 // create array of key
+00180                 timeBlock.Times.resize(numKeys);
+00181                 for(uint j=0;j<timeBlock.Times.size(); j++)
+00182                 {
+00183                         // get the key time and make it local to the timeBlock.
+00184                         timeBlock.Times[j]= timeList[firstKeyId+j] - timeBlock.TimeOffset;
+00185                 }
+00186         }
+00187 
+00188         // Compute other params
+00189         //===================
+00190         _BeginTime= beginTime;
+00191         _EndTime= endTime;
+00192         // compute deltatime for a frame to an other
+00193         uint    totalFrameCount= timeList[numKeys-1] - timeList[0];
+00194         nlassert(totalFrameCount>0);
+00195         _DeltaTime= (_EndTime-_BeginTime) / totalFrameCount;
+00196         _OODeltaTime= (float)(1.0 / _DeltaTime);
+00197         // Compute range of anim
+00198         _TotalRange= _EndTime-_BeginTime;
+00199         _OOTotalRange= float(1.0/_TotalRange);
+00200 
+00201 }
+

00108 {
+00109         // Eval time, and get key interpolation info
+00110         uint    keyId0;
+00111         uint    keyId1;
+00112         float   interpValue;
+00113         TEvalType       evalType= evalTime(date, _Keys.size(), keyId0, keyId1, interpValue);
+00114 
+00115         // Discard? 
+00116         if( evalType==EvalDiscard )
+00117                 return;
+00118         // One Key? easy, and quit.
+00119         else if( evalType==EvalKey0 )
+00120         {
+00121                 _Value.Value= _Keys[keyId0];
+00122         }
+00123         // interpolate
+00124         else if( evalType==EvalInterpolate )
+00125         {
+00126                 const CVector   &valueKey0= _Keys[keyId0];
+00127                 const CVector   &valueKey1= _Keys[keyId1];
+00128 
+00129                 // interpolate
+00130                 _Value.Value= valueKey0*(1-interpValue) + valueKey1*interpValue;
+00131         }
+00132         else
+00133         {
+00134                 nlstop;
+00135         }
+00136 
+00137 }
+

00212 {
+00213         // Empty? quit
+00214         if(numKeys==0)
+00215                 return EvalDiscard;
+00216 
+00217         // One Key? easy, and quit.
+00218         if(numKeys==1)
+00219         {
+00220                 keyId0= 0;
+00221                 return EvalKey0;
+00222         }
+00223 
+00224         // manage Loop
+00225         //=====================
+00226         float   localTime;
+00227         if(_LoopMode)
+00228         {
+00229                 nlassert(_TotalRange>0);
+00230                 // get relative to BeginTime.
+00231                 localTime= date-_BeginTime;
+00232 
+00233                 // force us to be in interval [0, _TotalRange[.
+00234                 if( localTime<0 || localTime>=_TotalRange )
+00235                 {
+00236                         double  d= localTime*_OOTotalRange;
+00237 
+00238                         // floor(d) is the truncated number of loops.
+00239                         d= localTime- floor(d)*_TotalRange;
+00240                         localTime= (float)d;
+00241 
+00242                         // For precision problems, ensure correct range.
+00243                         if(localTime<0 || localTime >= _TotalRange)
+00244                                 localTime= 0;
+00245                 }
+00246 
+00247         }
+00248         else
+00249         {
+00250                 // get relative to BeginTime.
+00251                 localTime= date-_BeginTime;
+00252         }
+00253 
+00254 
+00255         // Find the first key before localTime
+00256         //=====================
+00257         // get the frame in the track.
+00258         sint    frame= (sint)floor(localTime*_OODeltaTime);
+00259         // clamp to uint16
+00260         clamp(frame, 0, 65535);
+00261 
+00262         // Search the TimeBlock.
+00263         CTimeBlock      keyTB;
+00264         keyTB.TimeOffset= frame;
+00265         uint            tbId;
+00266         tbId= searchLowerBound(_TimeBlocks.getPtr(), _TimeBlocks.size(), keyTB);
+00267 
+00268         // get this timeBlock.
+00269         CTimeBlock      &timeBlock= _TimeBlocks[tbId];
+00270         // get frame relative to this timeBlock.
+00271         sint    frameRel= frame-timeBlock.TimeOffset;
+00272         // clamp to uint8
+00273         clamp(frameRel, 0, 255);
+00274         // get the key in this timeBlock.
+00275         uint    keyIdRel;
+00276         keyIdRel= searchLowerBound(timeBlock.Times.getPtr(), timeBlock.Times.size(), (uint8)frameRel);
+00277         
+00278         // Get the Frame and Value of Key0.
+00279         uint            frameKey0= timeBlock.TimeOffset + timeBlock.Times[keyIdRel];
+00280         // this is the key to evaluate
+00281         keyId0= timeBlock.KeyOffset + keyIdRel;
+00282 
+00283 
+00284         // Interpolate with next key
+00285         //=====================
+00286 
+00287         // If not the last Key
+00288         if(keyId0<numKeys-1)
+00289         {
+00290                 // Get the next key.
+00291                 keyId1= keyId0+1;
+00292                 uint            frameKey1;
+00293                 // If last key of the timeBlock, get the first time of the next timeBlock.
+00294                 if( keyIdRel+1 >= timeBlock.Times.size() )
+00295                 {
+00296                         nlassert(tbId+1<_TimeBlocks.size());
+00297                         frameKey1= _TimeBlocks[tbId+1].TimeOffset;
+00298                 }
+00299                 else
+00300                 {
+00301                         frameKey1= timeBlock.TimeOffset + timeBlock.Times[keyIdRel+1];
+00302                 }
+00303 
+00304                 // unpack time.
+00305                 float   time0= frameKey0*_DeltaTime;
+00306                 float   time1= frameKey1*_DeltaTime;
+00307 
+00308                 // interpolate.
+00309                 float   t= (localTime-time0);
+00310                 // If difference is one frame, optimize.
+00311                 if(frameKey1-frameKey0==1)
+00312                         t*= _OODeltaTime;
+00313                 else
+00314                         t/= (time1-time0);
+00315                 clamp(t, 0.f, 1.f);
+00316 
+00317                 // store this interp value.
+00318                 interpValue= t;
+00319 
+00320                 return EvalInterpolate;
+00321         }
+00322         // else (last key of anim), just eval this key.
+00323         return EvalKey0;
+00324 }
+

00068 {
+00069         return _BeginTime;
+00070 }
+

00074 {
+00075         return _EndTime;
+00076 }
+

00062 {
+00063         return _LoopMode;
+00064 }
+

00057 {
+00058         return _Value;
+00059 }
+

00203 {
+00204         NL3D_HAUTO_UTRACK_INTERPOLATE;
+00205 
+00206         // Evaluate it 
+00207         eval (time);
+00208 
+00209         // Get a pointer on the value
+00210         const CAnimatedValueBool *value=dynamic_cast<const CAnimatedValueBool*>(&getValue ());
+00211 
+00212         // Type is good ?
+00213         if (value)
+00214         {
+00215                 // Ok, return the value
+00216                 res=value->Value;
+00217                 return true;
+00218         }
+00219         else
+00220                 // No, return false
+00221                 return false;
+00222 }
+

00179 {
+00180         NL3D_HAUTO_UTRACK_INTERPOLATE;
+00181 
+00182         // Evaluate it 
+00183         eval (time);
+00184 
+00185         // Get a pointer on the value
+00186         const CAnimatedValueString *value=dynamic_cast<const CAnimatedValueString*>(&getValue ());
+00187 
+00188         // Type is good ?
+00189         if (value)
+00190         {
+00191                 // Ok, return the value
+00192                 res=value->Value;
+00193                 return true;
+00194         }
+00195         else
+00196                 // No, return false
+00197                 return false;
+00198 }
+

00155 {
+00156         NL3D_HAUTO_UTRACK_INTERPOLATE;
+00157 
+00158         // Evaluate it 
+00159         eval (time);
+00160 
+00161         // Get a pointer on the value
+00162         const CAnimatedValueQuat *value=dynamic_cast<const CAnimatedValueQuat*>(&getValue ());
+00163 
+00164         // Type is good ?
+00165         if (value)
+00166         {
+00167                 // Ok, return the value
+00168                 res=value->Value;
+00169                 return true;
+00170         }
+00171         else
+00172                 // No, return false
+00173                 return false;
+00174 }
+

00131 {
+00132         NL3D_HAUTO_UTRACK_INTERPOLATE;
+00133 
+00134         // Evaluate it 
+00135         eval (time);
+00136 
+00137         // Get a pointer on the value
+00138         const CAnimatedValueVector *value=dynamic_cast<const CAnimatedValueVector*>(&getValue ());
+00139 
+00140         // Type is good ?
+00141         if (value)
+00142         {
+00143                 // Ok, return the value
+00144                 res=value->Value;
+00145                 return true;
+00146         }
+00147         else
+00148                 // No, return false
+00149                 return false;
+00150 }
+

00107 {
+00108         NL3D_HAUTO_UTRACK_INTERPOLATE;
+00109 
+00110         // Evaluate it 
+00111         eval (time);
+00112 
+00113         // Get a pointer on the value
+00114         const CAnimatedValueRGBA *value=dynamic_cast<const CAnimatedValueRGBA*>(&getValue ());
+00115 
+00116         // Type is good ?
+00117         if (value)
+00118         {
+00119                 // Ok, return the value
+00120                 res=value->Value;
+00121                 return true;
+00122         }
+00123         else
+00124                 // No, return false
+00125                 return false;
+00126 }
+

00083 {
+00084         NL3D_HAUTO_UTRACK_INTERPOLATE;
+00085 
+00086         // Evaluate it 
+00087         eval (time);
+00088 
+00089         // Get a pointer on the value
+00090         const CAnimatedValueInt *value=dynamic_cast<const CAnimatedValueInt*>(&getValue ());
+00091 
+00092         // Type is good ?
+00093         if (value)
+00094         {
+00095                 // Ok, return the value
+00096                 res=value->Value;
+00097                 return true;
+00098         }
+00099         else
+00100                 // No, return false
+00101                 return false;
+00102 }
+

00063 {
+00064         /*
+00065         Version 0:
+00066                 - base version.
+00067         */
+00068         (void)f.serialVersion(0);
+00069 
+00070         // serial Time infos.
+00071         CTrackSampledCommon::serialCommon(f);
+00072 
+00073         // serial Keys.
+00074         f.serial(_Keys);
+00075 
+00076 }
+

00091 {
+00092         (void)f.serialVersion(0);
+00093 
+00094         f.serial(_LoopMode);
+00095         f.serial(_BeginTime);
+00096         f.serial(_EndTime) ;
+00097         f.serial(_TotalRange);
+00098         f.serial(_OOTotalRange);
+00099         f.serial(_DeltaTime);
+00100         f.serial(_OODeltaTime);
+00101         f.serial(_TimeBlocks);
+00102 
+00103 }
+

00205 {
+00206         _LoopMode= mode;
+00207 }
+

NL3D::CTrackSampledVector Class Reference

Detailed Description

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation


Public Member Functions
void	build (const std::vector< uint16 > &timeList, const std::vector< CVector > &keyList, float beginTime, float endTime)
	CTrackSampledVector ()
	Constructor.
virtual std::string	getClassName ()=0
	NLMISC_DECLARE_CLASS (CTrackSampledVector)
void	setLoopMode (bool mode)
	Change the loop mode. true default.
virtual	~CTrackSampledVector ()
From UTrack
virtual bool	interpolate (TAnimationTime time, bool &res)
virtual bool	interpolate (TAnimationTime time, std::string &res)
virtual bool	interpolate (TAnimationTime time, NLMISC::CQuat &res)
virtual bool	interpolate (TAnimationTime time, NLMISC::CVector &res)
virtual bool	interpolate (TAnimationTime time, NLMISC::CRGBA &res)
virtual bool	interpolate (TAnimationTime time, sint32 &res)
virtual bool	interpolate (TAnimationTime time, float &res)
From UTrack
virtual bool	interpolate (TAnimationTime time, bool &res)
virtual bool	interpolate (TAnimationTime time, std::string &res)
virtual bool	interpolate (TAnimationTime time, NLMISC::CQuat &res)
virtual bool	interpolate (TAnimationTime time, NLMISC::CVector &res)
virtual bool	interpolate (TAnimationTime time, NLMISC::CRGBA &res)
virtual bool	interpolate (TAnimationTime time, sint32 &res)
virtual bool	interpolate (TAnimationTime time, float &res)
From UTrack
virtual bool	interpolate (TAnimationTime time, bool &res)
virtual bool	interpolate (TAnimationTime time, std::string &res)
virtual bool	interpolate (TAnimationTime time, NLMISC::CQuat &res)
virtual bool	interpolate (TAnimationTime time, NLMISC::CVector &res)
virtual bool	interpolate (TAnimationTime time, NLMISC::CRGBA &res)
virtual bool	interpolate (TAnimationTime time, sint32 &res)
virtual bool	interpolate (TAnimationTime time, float &res)
From UTrack
virtual bool	interpolate (TAnimationTime time, bool &res)
virtual bool	interpolate (TAnimationTime time, std::string &res)
virtual bool	interpolate (TAnimationTime time, NLMISC::CQuat &res)
virtual bool	interpolate (TAnimationTime time, NLMISC::CVector &res)
virtual bool	interpolate (TAnimationTime time, NLMISC::CRGBA &res)