NL3D::CTrackSampledQuat Class Reference

#include <track_sampled_quat.h>

Inheritance diagram for NL3D::CTrackSampledQuat:

---

Detailed Description

This track is supposed to be Lighter in memory than CTrackKeyFramerTCBQuat, and also is maybe faster. The track is an oversampled version of CTrackKeyFramerTCBQuat (or any quat interpolator), to 30 fps for example, but each key is 9 bytes in memory, instead of 96. Only linear interpolation is performed (use CQuat::slerp) between 2 keys. And Keys are precomputed to be correctly on the same quaternion hemisphere from the preceding to the next.

9 bytes per key is achieved by encoding this way: 1 byte for the length/key time, measured in samples, and not in second (hence we can skip at max 255 keys). 8 byte for a light normalized quaternion: x,y,z,w are stored in 16 bits.

Author:

Lionel Berenguier

Nevrax France

Date:

2002

Definition at line 59 of file track_sampled_quat.h.

Public Member Functions
void	build (const std::vector< uint16 > &timeList, const std::vector< CQuat > &keyList, float beginTime, float endTime)
	CTrackSampledQuat ()
	Constructor.
virtual std::string	getClassName ()=0
	NLMISC_DECLARE_CLASS (CTrackSampledQuat)
void	setLoopMode (bool mode)
	Change the loop mode. true default.
virtual	~CTrackSampledQuat ()
virtual void	eval (const TAnimationTime &date)
virtual const IAnimatedValue &	getValue () const
virtual void	serial (NLMISC::IStream &f)
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
NLMISC::CObjectVector< CQuatPack, false >	_Keys
bool	_LoopMode
float	_OODeltaTime
float	_OOTotalRange
NLMISC::CObjectVector< CTimeBlock >	_TimeBlocks
float	_TotalRange
CAnimatedValueQuat	_Value

---

Member Enumeration Documentation

enum NL3D::CTrackSampledCommon::TEvalType [protected, inherited]

Enumeration values: EvalDiscard  EvalKey0  EvalInterpolate  Definition at line 103 of file track_sampled_common.h. {EvalDiscard, EvalKey0, EvalInterpolate};

---

Constructor & Destructor Documentation

NL3D::CTrackSampledQuat::CTrackSampledQuat (   )

Constructor. Definition at line 109 of file track_sampled_quat.cpp. { }

NL3D::CTrackSampledQuat::~CTrackSampledQuat (   )  [virtual]

Definition at line 114 of file track_sampled_quat.cpp. { }

---

Member Function Documentation

void NL3D::CTrackSampledQuat::build (  const std::vector< uint16 > &  timeList, const std::vector< CQuat > &  keyList, float  beginTime, float  endTime )

Build the track from a list of CKey. They must be already precompiled. ie they must all lies on the same hemisphere from prec key. nlassert if ! same length. Parameters: timeList  the list of key time. First must be ==0. nlassert if difference between 2 keys is > 255 keyList  the list of keys, not yet compressed to CQuatPack (done internally) beginTime  map to the timeList[0] time. endTime  map to the timeList[size-1] time. Definition at line 159 of file track_sampled_quat.cpp. References _Keys, NLMISC::CObjectVector< CTimeBlock >::clear(), NLMISC::CObjectVector< CQuatPack, false >::clear(), nlassert, NLMISC::CObjectVector< CQuatPack, false >::resize(), and uint. Referenced by NL3D::CAnimationOptimizer::optimizeTrack(). { nlassert( endTime>beginTime || (beginTime==endTime && keyList.size()<=1) ); nlassert( keyList.size()==timeList.size() ); uint i; // reset. uint numKeys= keyList.size(); _Keys.clear(); _TimeBlocks.clear(); // Build Common time information CTrackSampledCommon::buildCommon(timeList, beginTime, endTime); // Compute All Key values. //=================== _Keys.resize(numKeys); for(i=0; i<numKeys;i++) { _Keys[i].pack(keyList[i]); } }

void NL3D::CTrackSampledCommon::buildCommon (  const std::vector< uint16 > &  timeList, float  beginTime, float  endTime )  [protected, inherited]

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 NL3D::CTrackSampledCommon::_OODeltaTime, NL3D::CTrackSampledCommon::_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. { nlassert( endTime>beginTime || (beginTime==endTime && timeList.size()<=1) ); uint i; // reset. uint numKeys= timeList.size(); _TimeBlocks.clear(); // Special case of 0 or 1 key. //=================== if(numKeys<=1) { _BeginTime= beginTime; _EndTime= endTime; _TotalRange= 0; _OOTotalRange= 0; _DeltaTime= 0; _OODeltaTime= 0; if(numKeys==1) { _TimeBlocks.resize(1); _TimeBlocks[0].TimeOffset= 0; _TimeBlocks[0].Times.resize(1); _TimeBlocks[0].Times[0]= 0; } return; } // Compute All Time blocks. //=================== sint32 lastBlockFrame= -1000000; nlassert(timeList[0] == 0); // Header info for creating timeBlocks vector<uint> timeBlockKeyId; vector<uint> timeBlockNumKeys; // compute how many time block we need. for(i=0; i<numKeys; i++) { // verify growing order, and time difference. if(i>0) { nlassert(timeList[i]>timeList[i-1]); nlassert(timeList[i]-timeList[i-1] <= 255 ); } // If the current frame is to far from the last TimeBlock frame (or if 1st timeBlock), must create a new timeBlock if(timeList[i]-lastBlockFrame>255) { // create a new timeblock timeBlockKeyId.push_back(i); // Add this key to this new time Block (numKey == 1). timeBlockNumKeys.push_back(1); lastBlockFrame= timeList[i]; } else { // Add this key to the timeBlock. timeBlockNumKeys[timeBlockNumKeys.size()-1]++; } } // Build the timeBlocks. _TimeBlocks.resize(timeBlockKeyId.size()); for(i=0; i<timeBlockKeyId.size(); i++) { CTimeBlock &timeBlock= _TimeBlocks[i]; uint firstKeyId= timeBlockKeyId[i]; uint numKeys= timeBlockNumKeys[i]; // compute the offset time and key timeBlock.KeyOffset= firstKeyId; timeBlock.TimeOffset= timeList[firstKeyId]; // create array of key timeBlock.Times.resize(numKeys); for(uint j=0;j<timeBlock.Times.size(); j++) { // get the key time and make it local to the timeBlock. timeBlock.Times[j]= timeList[firstKeyId+j] - timeBlock.TimeOffset; } } // Compute other params //=================== _BeginTime= beginTime; _EndTime= endTime; // compute deltatime for a frame to an other uint totalFrameCount= timeList[numKeys-1] - timeList[0]; nlassert(totalFrameCount>0); _DeltaTime= (_EndTime-_BeginTime) / totalFrameCount; _OODeltaTime= (float)(1.0 / _DeltaTime); // Compute range of anim _TotalRange= _EndTime-_BeginTime; _OOTotalRange= float(1.0/_TotalRange); }

void NL3D::CTrackSampledQuat::eval (  const TAnimationTime &  date  )  [virtual]

Evaluation of the value of the track for this time. The result is internaly stored to simplify access at the polymorphic values. To get the value, call ITrack::getValue(). Implements NL3D::ITrack. Definition at line 186 of file track_sampled_quat.cpp. References _Keys, NL3D::CTrackSampledCommon::evalTime(), nlstop, NLMISC::CObjectVector< CQuatPack, false >::size(), NL3D::TAnimationTime, uint, NL3D::CTrackSampledQuat::CQuatPack::unpack(), and NL3D::CAnimatedValueBlendable< T >::Value. { // Eval time, and get key interpolation info uint keyId0; uint keyId1; float interpValue; TEvalType evalType= evalTime(date, _Keys.size(), keyId0, keyId1, interpValue); // Discard? if( evalType==EvalDiscard ) return; // One Key? easy, and quit. else if( evalType==EvalKey0 ) { _Keys[keyId0].unpack(_Value.Value); } // interpolate else if( evalType==EvalInterpolate ) { CQuatPack valueKey0= _Keys[keyId0]; CQuatPack valueKey1= _Keys[keyId1]; // If the 2 keys have same value, just unpack. if(valueKey0 == valueKey1) { valueKey0.unpack(_Value.Value); } // else interpolate else { // unpack key value. CQuat quat0, quat1; valueKey0.unpack(quat0); valueKey1.unpack(quat1); // interpolate _Value.Value= CQuat::slerp(quat0, quat1, interpValue); } } else { nlstop; } }

CTrackSampledCommon::TEvalType NL3D::CTrackSampledCommon::evalTime (  const TAnimationTime &  date, uint  numKeys, uint &  keyId0, uint &  keyId1, float &  interpValue )  [protected, inherited]

Definition at line 211 of file track_sampled_common.cpp. References NL3D::CTrackSampledCommon::_OODeltaTime, NL3D::CTrackSampledCommon::_TimeBlocks, NLMISC::clamp(), NL3D::CTrackSampledCommon::EvalDiscard, NL3D::CTrackSampledCommon::EvalInterpolate, NL3D::CTrackSampledCommon::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 eval(). { // Empty? quit if(numKeys==0) return EvalDiscard; // One Key? easy, and quit. if(numKeys==1) { keyId0= 0; return EvalKey0; } // manage Loop //===================== float localTime; if(_LoopMode) { nlassert(_TotalRange>0); // get relative to BeginTime. localTime= date-_BeginTime; // force us to be in interval [0, _TotalRange[. if( localTime<0 || localTime>=_TotalRange ) { double d= localTime*_OOTotalRange; // floor(d) is the truncated number of loops. d= localTime- floor(d)*_TotalRange; localTime= (float)d; // For precision problems, ensure correct range. if(localTime<0 || localTime >= _TotalRange) localTime= 0; } } else { // get relative to BeginTime. localTime= date-_BeginTime; } // Find the first key before localTime //===================== // get the frame in the track. sint frame= (sint)floor(localTime*_OODeltaTime); // clamp to uint16 clamp(frame, 0, 65535); // Search the TimeBlock. CTimeBlock keyTB; keyTB.TimeOffset= frame; uint tbId; tbId= searchLowerBound(_TimeBlocks.getPtr(), _TimeBlocks.size(), keyTB); // get this timeBlock. CTimeBlock &timeBlock= _TimeBlocks[tbId]; // get frame relative to this timeBlock. sint frameRel= frame-timeBlock.TimeOffset; // clamp to uint8 clamp(frameRel, 0, 255); // get the key in this timeBlock. uint keyIdRel; keyIdRel= searchLowerBound(timeBlock.Times.getPtr(), timeBlock.Times.size(), (uint8)frameRel); // Get the Frame and Value of Key0. uint frameKey0= timeBlock.TimeOffset + timeBlock.Times[keyIdRel]; // this is the key to evaluate keyId0= timeBlock.KeyOffset + keyIdRel; // Interpolate with next key //===================== // If not the last Key if(keyId0<numKeys-1) { // Get the next key. keyId1= keyId0+1; uint frameKey1; // If last key of the timeBlock, get the first time of the next timeBlock. if( keyIdRel+1 >= timeBlock.Times.size() ) { nlassert(tbId+1<_TimeBlocks.size()); frameKey1= _TimeBlocks[tbId+1].TimeOffset; } else { frameKey1= timeBlock.TimeOffset + timeBlock.Times[keyIdRel+1]; } // unpack time. float time0= frameKey0*_DeltaTime; float time1= frameKey1*_DeltaTime; // interpolate. float t= (localTime-time0); // If difference is one frame, optimize. if(frameKey1-frameKey0==1) t*= _OODeltaTime; else t/= (time1-time0); clamp(t, 0.f, 1.f); // store this interp value. interpValue= t; return EvalInterpolate; } // else (last key of anim), just eval this key. return EvalKey0; }

TAnimationTime NL3D::CTrackSampledCommon::getBeginTime (   )  const [virtual, inherited]

Get the begin time of the track Implements NL3D::UTrack. Definition at line 67 of file track_sampled_common.cpp. References NL3D::TAnimationTime. { return _BeginTime; }

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, inherited]

Get the end time of the track Implements NL3D::UTrack. Definition at line 73 of file track_sampled_common.cpp. References NL3D::TAnimationTime. { return _EndTime; }

bool NL3D::CTrackSampledCommon::getLoopMode (   )  const [virtual, inherited]

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. { return _LoopMode; }

const IAnimatedValue & NL3D::CTrackSampledQuat::getValue (   )  const [virtual]

Get the track current value. Returns: the last value evaluated by ITrack::eval(). Implements NL3D::ITrack. Definition at line 119 of file track_sampled_quat.cpp. { return _Value; }

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. { NL3D_HAUTO_UTRACK_INTERPOLATE; // Evaluate it eval (time); // Get a pointer on the value const CAnimatedValueBool *value=dynamic_cast<const CAnimatedValueBool*>(&getValue ()); // Type is good ? if (value) { // Ok, return the value res=value->Value; return true; } else // No, return false return false; }

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. { NL3D_HAUTO_UTRACK_INTERPOLATE; // Evaluate it eval (time); // Get a pointer on the value const CAnimatedValueString *value=dynamic_cast<const CAnimatedValueString*>(&getValue ()); // Type is good ? if (value) { // Ok, return the value res=value->Value; return true; } else // No, return false return false; }

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. { NL3D_HAUTO_UTRACK_INTERPOLATE; // Evaluate it eval (time); // Get a pointer on the value const CAnimatedValueQuat *value=dynamic_cast<const CAnimatedValueQuat*>(&getValue ()); // Type is good ? if (value) { // Ok, return the value res=value->Value; return true; } else // No, return false return false; }

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. { NL3D_HAUTO_UTRACK_INTERPOLATE; // Evaluate it eval (time); // Get a pointer on the value const CAnimatedValueVector *value=dynamic_cast<const CAnimatedValueVector*>(&getValue ()); // Type is good ? if (value) { // Ok, return the value res=value->Value; return true; } else // No, return false return false; }

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. { NL3D_HAUTO_UTRACK_INTERPOLATE; // Evaluate it eval (time); // Get a pointer on the value const CAnimatedValueRGBA *value=dynamic_cast<const CAnimatedValueRGBA*>(&getValue ()); // Type is good ? if (value) { // Ok, return the value res=value->Value; return true; } else // No, return false return false; }

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. { NL3D_HAUTO_UTRACK_INTERPOLATE; // Evaluate it eval (time); // Get a pointer on the value const CAnimatedValueInt *value=dynamic_cast<const CAnimatedValueInt*>(&getValue ()); // Type is good ? if (value) { // Ok, return the value res=value->Value; return true; } else // No, return false return false; }

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.

NL3D::CTrackSampledQuat::NLMISC_DECLARE_CLASS (  CTrackSampledQuat   )

void NL3D::CTrackSampledQuat::serial (  NLMISC::IStream &  f  )  [virtual]

Implements NLMISC::IStreamable. Definition at line 125 of file track_sampled_quat.cpp. References _Keys, NLMISC::IStream::serial(), NLMISC::IStream::serialVersion(), and sint. { /* Version 1: - split class with base CTrackSampledCommon (must add a version in it). Version 0: - base version. */ sint ver= f.serialVersion(1); if( ver<=0 ) { // serial Time infos, directly in CTrackSampledCommon f.serial(_LoopMode); f.serial(_BeginTime); f.serial(_EndTime) ; f.serial(_TotalRange); f.serial(_OOTotalRange); f.serial(_DeltaTime); f.serial(_OODeltaTime); f.serial(_TimeBlocks); } else { // serial Time infos. CTrackSampledCommon::serialCommon(f); } // serial Keys. f.serial(_Keys); }

void NL3D::CTrackSampledCommon::serialCommon (  NLMISC::IStream &  f  )  [protected, inherited]

Definition at line 90 of file track_sampled_common.cpp. References NL3D::CTrackSampledCommon::_OODeltaTime, NL3D::CTrackSampledCommon::_TimeBlocks, NLMISC::IStream::serial(), and NLMISC::IStream::serialVersion(). { (void)f.serialVersion(0); f.serial(_LoopMode); f.serial(_BeginTime); f.serial(_EndTime) ; f.serial(_TotalRange); f.serial(_OOTotalRange); f.serial(_DeltaTime); f.serial(_OODeltaTime); f.serial(_TimeBlocks); }

void NL3D::CTrackSampledCommon::setLoopMode (  bool  mode  )  [inherited]

Change the loop mode. true default. Definition at line 204 of file track_sampled_common.cpp. Referenced by NL3D::CAnimationOptimizer::optimizeTrack(). { _LoopMode= mode; }

---

Field Documentation

float NL3D::CTrackSampledCommon::_BeginTime [protected, inherited]

Definition at line 68 of file track_sampled_common.h.

float NL3D::CTrackSampledCommon::_DeltaTime [protected, inherited]

Definition at line 73 of file track_sampled_common.h.

float NL3D::CTrackSampledCommon::_EndTime [protected, inherited]

Definition at line 69 of file track_sampled_common.h.

NLMISC::CObjectVector<CQuatPack, false> NL3D::CTrackSampledQuat::_Keys [protected]

Definition at line 131 of file track_sampled_quat.h. Referenced by build(), eval(), and serial().

bool NL3D::CTrackSampledCommon::_LoopMode [protected, inherited]

Definition at line 67 of file track_sampled_common.h.

float NL3D::CTrackSampledCommon::_OODeltaTime [protected, inherited]

Definition at line 74 of file track_sampled_common.h. Referenced by NL3D::CTrackSampledCommon::buildCommon(), NL3D::CTrackSampledCommon::evalTime(), and NL3D::CTrackSampledCommon::serialCommon().

float NL3D::CTrackSampledCommon::_OOTotalRange [protected, inherited]

Definition at line 71 of file track_sampled_common.h.

NLMISC::CObjectVector<CTimeBlock> NL3D::CTrackSampledCommon::_TimeBlocks [protected, inherited]

Definition at line 98 of file track_sampled_common.h. Referenced by NL3D::CTrackSampledCommon::buildCommon(), NL3D::CTrackSampledCommon::evalTime(), and NL3D::CTrackSampledCommon::serialCommon().

float NL3D::CTrackSampledCommon::_TotalRange [protected, inherited]

Definition at line 70 of file track_sampled_common.h.

CAnimatedValueQuat NL3D::CTrackSampledQuat::_Value [protected]

Definition at line 128 of file track_sampled_quat.h.

---

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

• track_sampled_quat.h
• track_sampled_quat.cpp

---