From 0ea5fc66924303d1bf73ba283a383e2aadee02f2 Mon Sep 17 00:00:00 2001 From: neodarz Date: Sat, 11 Aug 2018 20:21:34 +0200 Subject: Initial commit --- docs/doxygen/nel/a03589.html | 1552 ++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1552 insertions(+) create mode 100644 docs/doxygen/nel/a03589.html (limited to 'docs/doxygen/nel/a03589.html') diff --git a/docs/doxygen/nel/a03589.html b/docs/doxygen/nel/a03589.html new file mode 100644 index 00000000..804c6ae6 --- /dev/null +++ b/docs/doxygen/nel/a03589.html @@ -0,0 +1,1552 @@ + + +NeL: NL3D::CTrackSampledCommon class Reference + + + +

NL3D::CTrackSampledCommon Class Reference

#include <track_sampled_common.h> +

Inheritance diagram for NL3D::CTrackSampledCommon: +

+ + + + + + + + +

Detailed Description

+Abstract Base class for CTrackSampledQuat and CTrackSampledVector

Author:: Lionel Berenguier
+Nevrax France

Date:: 2002

+ +

+Definition at line 45 of file track_sampled_common.h. + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

Public Member Functions
CTrackSampledCommon ()
Constructor.

virtual void eval (const TAnimationTime &date)=0
virtual std::string getClassName ()=0
virtual const IAnimatedValue & getValue () const=0
virtual void serial (IStream &f)=0
void setLoopMode (bool mode)
Change the loop mode. true default.

virtual ~CTrackSampledCommon ()

Protected Types
enum TEvalType { EvalDiscard, +EvalKey0, +EvalInterpolate + }

Protected Member Functions
void buildCommon (const std::vector< uint16 > &timeList, float beginTime, float endTime)
TEvalType evalTime (const TAnimationTime &date, uint numKeys, uint &keyId0, uint &keyId1, float &interpValue)
void serialCommon (NLMISC::IStream &f)

Protected Attributes
float _BeginTime
float _DeltaTime
float _EndTime
bool _LoopMode
float _OODeltaTime
float _OOTotalRange
NLMISC::CObjectVector< CTimeBlock > _TimeBlocks
float _TotalRange
+

Member Enumeration Documentation

+ + + + +
+ + +
enum NL3D::CTrackSampledCommon::TEvalType [protected] +
+
+ + + + + +
+ + + +
+
Enumeration values:
+ + + + +
EvalDiscard +
EvalKey0 +
EvalInterpolate +
+
+ +
+Definition at line 103 of file track_sampled_common.h. +
+
00103 {EvalDiscard, EvalKey0, EvalInterpolate}; +

+

Constructor & Destructor Documentation

+ + + + +
+ + + + + + + + + +
NL3D::CTrackSampledCommon::CTrackSampledCommon ( )
+
+ + + + + +
+ + + +
+Constructor. +
+ +
+Definition at line 50 of file track_sampled_common.cpp. +
+
00051 { +00052 _LoopMode= true; +00053 } +

+

+ + + + +
+ + + + + + + + + +
NL3D::CTrackSampledCommon::~CTrackSampledCommon ( ) [virtual]
+
+ + + + + +
+ + + +
+ +
+Definition at line 56 of file track_sampled_common.cpp. +
+
00057 { +00058 } +

+

Member Function Documentation

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + +
void NL3D::CTrackSampledCommon::buildCommon ( const std::vector< uint16 > & timeList,
float beginTime,
float endTime
) [protected]
+
+ + + + + +
+ + + +
+Build the track time from a list of Keys.
Parameters:
+ + + + +
timeList the list of key time. First must be ==0. nlassert if difference between 2 keys is > 255
beginTime map to the timeList[0] time.
endTime map to the timeList[size-1] time.
+
+ +
+Definition at line 106 of file track_sampled_common.cpp. +
+References _OODeltaTime, _TimeBlocks, NLMISC::CObjectVector< CTimeBlock >::clear(), NL3D::CTrackSampledCommon::CTimeBlock::KeyOffset, nlassert, NLMISC::CObjectVector< uint8, false >::resize(), NLMISC::CObjectVector< CTimeBlock >::resize(), sint32, NLMISC::CObjectVector< uint8, false >::size(), NL3D::CTrackSampledCommon::CTimeBlock::TimeOffset, NL3D::CTrackSampledCommon::CTimeBlock::Times, and uint. +
+
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 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
CTrackSampledCommon::TEvalType NL3D::CTrackSampledCommon::evalTime ( const TAnimationTime & date,
uint numKeys,
uint & keyId0,
uint & keyId1,
float & interpValue
) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 211 of file track_sampled_common.cpp. +
+References _OODeltaTime, _TimeBlocks, NLMISC::clamp(), EvalDiscard, EvalInterpolate, EvalKey0, NLMISC::CObjectVector< uint8, false >::getPtr(), NLMISC::CObjectVector< CTimeBlock >::getPtr(), NL3D::CTrackSampledCommon::CTimeBlock::KeyOffset, nlassert, NLMISC::searchLowerBound(), sint, NLMISC::CObjectVector< uint8, false >::size(), NLMISC::CObjectVector< CTimeBlock >::size(), t, NL3D::TAnimationTime, NL3D::CTrackSampledCommon::CTimeBlock::TimeOffset, NL3D::CTrackSampledCommon::CTimeBlock::Times, uint, and uint8. +
+Referenced by NL3D::CTrackSampledVector::eval(), and NL3D::CTrackSampledQuat::eval(). +
+
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 } +

+

+ + + + +
+ + + + + + + + + +
TAnimationTime NL3D::CTrackSampledCommon::getBeginTime ( ) const [virtual]
+
+ + + + + +
+ + + +
+Get the begin time of the track +
+Implements NL3D::UTrack. +
+Definition at line 67 of file track_sampled_common.cpp. +
+References NL3D::TAnimationTime. +
+
00068 { +00069 return _BeginTime; +00070 } +

+

+ + + + +
+ + + + + + + + + +
virtual std::string NLMISC::IClassable::getClassName ( ) [pure virtual, inherited]
+
+ + + + + +
+ + + +
+ +
+Implemented in NLAIAGENT::CNumericIndex, NLAIC::IPointerGestion, NLAIC::CIdentType, and CAutomataDesc. +
+Referenced by NLMISC::CClassRegistry::checkObject(), and NL3D::GetTextureSize().
+

+ + + + +
+ + + + + + + + + +
TAnimationTime NL3D::CTrackSampledCommon::getEndTime ( ) const [virtual]
+
+ + + + + +
+ + + +
+Get the end time of the track +
+Implements NL3D::UTrack. +
+Definition at line 73 of file track_sampled_common.cpp. +
+References NL3D::TAnimationTime. +
+
00074 { +00075 return _EndTime; +00076 } +

+

+ + + + +
+ + + + + + + + + +
bool NL3D::CTrackSampledCommon::getLoopMode ( ) const [virtual]
+
+ + + + + +
+ + + +
+get LoopMode. 2 mode only: "constant" (<=>false), and "loop" (<=> true). NB: same mode if time < getBeginTIme() and if time > getEndTime() +
+Implements NL3D::ITrack. +
+Definition at line 61 of file track_sampled_common.cpp. +
+
00062 { +00063 return _LoopMode; +00064 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NL3D::ITrack::interpolate ( TAnimationTime time,
bool & res
) [virtual, inherited]
+
+ + + + + +
+ + + +
+Interplation a bool value. You should be sure that the track you use to interpolate your value is a bool track! An assertion will be raised in debug if the type is wrong.
+
Parameters:
+ + + +
time is the time you want the evaluate the value. If time higher than the time gived by getEndTime (), the value returned is the interpolation value at getEndTime (). If time smaller than the time gived by getBeginTime (), the value returned is the interpolation value at getBeginTime ().
res is the reference on the value to get the result.
+
+
Returns:
true if interplation is successful. false if the type asked is wrong.
+ +
+Implements NL3D::UTrack. +
+Definition at line 202 of file track.cpp. +
+References NL3D::CAnimatedValueBool, NL3D::ITrack::eval(), NL3D::ITrack::getValue(), NL3D_HAUTO_UTRACK_INTERPOLATE, res, NL3D::TAnimationTime, and value. +
+
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 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NL3D::ITrack::interpolate ( TAnimationTime time,
std::string & res
) [virtual, inherited]
+
+ + + + + +
+ + + +
+Interplation a string value. You should be sure that the track you use to interpolate your value is a string track! An assertion will be raised in debug if the type is wrong.
+
Parameters:
+ + + +
time is the time you want the evaluate the value. If time higher than the time gived by getEndTime (), the value returned is the interpolation value at getEndTime (). If time smaller than the time gived by getBeginTime (), the value returned is the interpolation value at getBeginTime ().
res is the reference on the value to get the result.
+
+
Returns:
true if interplation is successful. false if the type asked is wrong.
+ +
+Implements NL3D::UTrack. +
+Definition at line 178 of file track.cpp. +
+References NL3D::CAnimatedValueString, NL3D::ITrack::eval(), NL3D::ITrack::getValue(), NL3D_HAUTO_UTRACK_INTERPOLATE, res, NL3D::TAnimationTime, and value. +
+
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 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NL3D::ITrack::interpolate ( TAnimationTime time,
NLMISC::CQuat & res
) [virtual, inherited]
+
+ + + + + +
+ + + +
+Interplation a CQuat value. You should be sure that the track you use to interpolate your value is a CQuat track! An assertion will be raised in debug if the type is wrong.
+
Parameters:
+ + + +
time is the time you want the evaluate the value. If time higher than the time gived by getEndTime (), the value returned is the interpolation value at getEndTime (). If time smaller than the time gived by getBeginTime (), the value returned is the interpolation value at getBeginTime ().
res is the reference on the value to get the result.
+
+
Returns:
true if interplation is successful. false if the type asked is wrong.
+ +
+Implements NL3D::UTrack. +
+Definition at line 154 of file track.cpp. +
+References NL3D::CAnimatedValueQuat, NL3D::ITrack::eval(), NL3D::ITrack::getValue(), NL3D_HAUTO_UTRACK_INTERPOLATE, res, NL3D::TAnimationTime, and value. +
+
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 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NL3D::ITrack::interpolate ( TAnimationTime time,
NLMISC::CVector & res
) [virtual, inherited]
+
+ + + + + +
+ + + +
+Interplation a CVector value. You should be sure that the track you use to interpolate your value is a CVector track! An assertion will be raised in debug if the type is wrong.
+
Parameters:
+ + + +
time is the time you want the evaluate the value. If time higher than the time gived by getEndTime (), the value returned is the interpolation value at getEndTime (). If time smaller than the time gived by getBeginTime (), the value returned is the interpolation value at getBeginTime ().
res is the reference on the value to get the result.
+
+
Returns:
true if interplation is successful. false if the type asked is wrong.
+ +
+Implements NL3D::UTrack. +
+Definition at line 130 of file track.cpp. +
+References NL3D::CAnimatedValueVector, NL3D::ITrack::eval(), NL3D::ITrack::getValue(), NL3D_HAUTO_UTRACK_INTERPOLATE, res, NL3D::TAnimationTime, and value. +
+
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 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NL3D::ITrack::interpolate ( TAnimationTime time,
NLMISC::CRGBA & res
) [virtual, inherited]
+
+ + + + + +
+ + + +
+Interplation a CRGBA value. You should be sure that the track you use to interpolate your value is an CRGBA track! An assertion will be raised in debug if the type is wrong.
+
Parameters:
+ + + +
time is the time you want the evaluate the value. If time higher than the time gived by getEndTime (), the value returned is the interpolation value at getEndTime (). If time smaller than the time gived by getBeginTime (), the value returned is the interpolation value at getBeginTime ().
res is the reference on the value to get the result.
+
+
Returns:
true if interplation is successful. false if the type asked is wrong.
+ +
+Implements NL3D::UTrack. +
+Definition at line 106 of file track.cpp. +
+References NL3D::CAnimatedValueRGBA, NL3D::ITrack::eval(), NL3D::ITrack::getValue(), NL3D_HAUTO_UTRACK_INTERPOLATE, res, NL3D::TAnimationTime, and value. +
+
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 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
bool NL3D::ITrack::interpolate ( TAnimationTime time,
sint32 & res
) [virtual, inherited]
+
+ + + + + +
+ + + +
+Interplation an integer value. You should be sure that the track you use to interpolate your value is an integer track! An assertion will be raised in debug if the type is wrong.
+
Parameters:
+ + + +
time is the time you want the evaluate the value. If time higher than the time gived by getEndTime (), the value returned is the interpolation value at getEndTime (). If time smaller than the time gived by getBeginTime (), the value returned is the interpolation value at getBeginTime ().
res is the reference on the value to get the result.
+
+
Returns:
true if interplation is successful. false if the type asked is wrong.
+ +
+Implements NL3D::UTrack. +
+Definition at line 82 of file track.cpp. +
+References NL3D::CAnimatedValueInt, NL3D::ITrack::eval(), NL3D::ITrack::getValue(), NL3D_HAUTO_UTRACK_INTERPOLATE, res, sint32, NL3D::TAnimationTime, and value. +
+
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 } +

+

+ + + + +
+ + + + + + + + + + + + + + + + + + + +
virtual bool NL3D::ITrack::interpolate ( TAnimationTime time,
float & res
) [virtual, inherited]
+
+ + + + + +
+ + + +
+Interplation a float value. You should be sure that the track you use to interpolate your value is a float track! An assertion will be raised in debug if the type is wrong.
+
Parameters:
+ + + +
time is the time you want the evaluate the value. If time higher than the time gived by getEndTime (), the value returned is the interpolation value at getEndTime (). If time smaller than the time gived by getBeginTime (), the value returned is the interpolation value at getBeginTime ().
res is the reference on the value to get the result.
+
+
Returns:
true if interplation is successful. false if the type asked is wrong.
+ +
+Implements NL3D::UTrack.
+

+ + + + +
+ + + + + + + + + + +
void NL3D::CTrackSampledCommon::serialCommon ( NLMISC::IStream & f ) [protected]
+
+ + + + + +
+ + + +
+ +
+Definition at line 90 of file track_sampled_common.cpp. +
+References _OODeltaTime, _TimeBlocks, NLMISC::IStream::serial(), and NLMISC::IStream::serialVersion(). +
+
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 } +

+

+ + + + +
+ + + + + + + + + + +
void NL3D::CTrackSampledCommon::setLoopMode ( bool mode )
+
+ + + + + +
+ + + +
+Change the loop mode. true default. +
+ +
+Definition at line 204 of file track_sampled_common.cpp. +
+Referenced by NL3D::CAnimationOptimizer::optimizeTrack(). +
+
00205 { +00206 _LoopMode= mode; +00207 } +

+

Field Documentation

+ + + + +
+ + +
float NL3D::CTrackSampledCommon::_BeginTime [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 68 of file track_sampled_common.h.
+

+ + + + +
+ + +
float NL3D::CTrackSampledCommon::_DeltaTime [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 73 of file track_sampled_common.h.
+

+ + + + +
+ + +
float NL3D::CTrackSampledCommon::_EndTime [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 69 of file track_sampled_common.h.
+

+ + + + +
+ + +
bool NL3D::CTrackSampledCommon::_LoopMode [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 67 of file track_sampled_common.h.
+

+ + + + +
+ + +
float NL3D::CTrackSampledCommon::_OODeltaTime [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 74 of file track_sampled_common.h. +
+Referenced by buildCommon(), evalTime(), and serialCommon().
+

+ + + + +
+ + +
float NL3D::CTrackSampledCommon::_OOTotalRange [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 71 of file track_sampled_common.h.
+

+ + + + +
+ + +
NLMISC::CObjectVector<CTimeBlock> NL3D::CTrackSampledCommon::_TimeBlocks [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 98 of file track_sampled_common.h. +
+Referenced by buildCommon(), evalTime(), and serialCommon().
+

+ + + + +
+ + +
float NL3D::CTrackSampledCommon::_TotalRange [protected] +
+
+ + + + + +
+ + + +
+ +
+Definition at line 70 of file track_sampled_common.h.
+

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

Generated on Tue Mar 16 08:13:38 2004 for NeL by + +

+1.3.6

+ + -- cgit v1.2.1


Public Member Functions
	CTrackSampledCommon ()
	Constructor.
virtual void	eval (const TAnimationTime &date)=0
virtual std::string	getClassName ()=0
virtual const IAnimatedValue &	getValue () const=0
virtual void	serial (IStream &f)=0
void	setLoopMode (bool mode)
	Change the loop mode. true default.
virtual	~CTrackSampledCommon ()
Protected Types
enum	TEvalType { EvalDiscard, +EvalKey0, +EvalInterpolate + }
Protected Member Functions
void	buildCommon (const std::vector< uint16 > &timeList, float beginTime, float endTime)
TEvalType	evalTime (const TAnimationTime &date, uint numKeys, uint &keyId0, uint &keyId1, float &interpValue)
void	serialCommon (NLMISC::IStream &f)
Protected Attributes
float	_BeginTime
float	_DeltaTime
float	_EndTime
bool	_LoopMode
float	_OODeltaTime
float	_OOTotalRange
NLMISC::CObjectVector< CTimeBlock >	_TimeBlocks
float	_TotalRange