#include <track_tcb.h>
Inheritance diagram for CTrackKeyFramerTCB< CKeyTCBQuat, NLMISC::CAngleAxis >:
Nevrax France
Definition at line 386 of file track_tcb.h.
Public Member Functions | |
virtual const IAnimatedValue & | getValue () const |
From ITrack. | |
From ITrackKeyFramer | |
virtual void | compile () |
compile (precalc). | |
virtual void | evalKey (const CKeyTCBQuat *previous, const CKeyTCBQuat *next, TAnimationTime datePrevious, TAnimationTime dateNext, TAnimationTime date) |
evalKey (runtime). | |
Private Types | |
typedef TMapTimeCKey::iterator | TMapTimeCKeyIterator |
Private Member Functions | |
void | compileTCBEase (TMapTimeCKey &mapKey, bool loopMode) |
compute TCB ease information. | |
void | computeHermiteBasis (float d, float hb[4]) |
void | computeTCBFactors (const CKeyT &key, float timeBefore, float time, float timeAfter, float rangeDelta, bool firstKey, bool endKey, bool isLoop, float &ksm, float &ksp, float &kdm, float &kdp) |
void | computeTCBKey (CKeyTCBQuat &keyBefore, CKeyTCBQuat &key, CKeyTCBQuat &keyAfter, float timeBefore, float time, float timeAfter, float rangeDelta, bool firstKey, bool endKey, bool isLoop) |
float | ease (const CKeyT *key, float d) |
Private Attributes | |
CAnimatedValueBlendable< CQuat > | _Value |
|
Definition at line 51 of file track_tcb.h. |
|
compile (precalc).
Definition at line 430 of file track_tcb.h. References CTCBTools< CKeyT, T, TMapTimeCKey >::compileTCBEase(), CTrackKeyFramerTCB< CKeyT, T >::computeTCBKey(), NLMISC::CMatrix::invert(), NLMISC::CMatrix::normalize(), NLMISC::CMatrix::setRot(), and sint.
00431 { 00432 ITrackKeyFramer<CKeyTCBQuat>::compile(); 00433 00434 // Ease Precompute. 00435 compileTCBEase(_MapKey, getLoopMode()); 00436 00437 TMapTimeCKey::iterator it; 00438 TMapTimeCKey::iterator itNext; 00439 TMapTimeCKey::iterator itPrev; 00440 00441 // Compute absolute quaternions. 00442 for (it= _MapKey.begin();it!=_MapKey.end();) 00443 { 00444 CKeyTCBQuat &key= it->second; 00445 00446 // Compute Local AngleAxis. 00447 if(it!= _MapKey.begin()) 00448 { 00449 NLMISC::CMatrix mat; 00450 mat.setRot(itPrev->second.Quat); 00451 mat.invert(); 00452 key.LocalAngleAxis.Axis= mat*key.Value.Axis; 00453 key.LocalAngleAxis.Angle= key.Value.Angle; 00454 } 00455 else 00456 key.LocalAngleAxis= key.Value; 00457 00458 00459 key.LocalAngleAxis.Axis.normalize(); 00460 // make angle positive. 00461 if(key.LocalAngleAxis.Angle<0.f) 00462 { 00463 key.LocalAngleAxis.Axis= -key.LocalAngleAxis.Axis; 00464 key.LocalAngleAxis.Angle= -key.LocalAngleAxis.Angle; 00465 } 00466 00467 // relative quat 00468 key.Quat.setAngleAxis(key.LocalAngleAxis); 00469 00470 // absolute quat 00471 if (it!= _MapKey.begin()) 00472 key.Quat = itPrev->second.Quat * key.Quat; 00473 00474 // next key. 00475 itPrev= it; 00476 it++; 00477 } 00478 00479 // Tangents Precompute. 00480 sint nKeys= _MapKey.size(); 00481 if(nKeys<=1) 00482 return; 00483 00484 // rangeDelta is the length of effective Range - length of LastKey-FirstKey. 00485 // NB: if RangeLock, rangeDelta==0. 00486 float rangeDelta; 00487 // NB: _RangeDelta has just been compiled in ITrackKeyFramer<CKeyTCBQuat>::compile(). 00488 rangeDelta= getCompiledRangeDelta(); 00489 00490 it= _MapKey.begin(); // first key. 00491 itNext= it; itNext++; // second key. 00492 itPrev= _MapKey.end(); itPrev--; // last key. 00493 00494 // Compute all keys. 00495 for(;it!=_MapKey.end();) 00496 { 00497 // NB: we are the last key if itNext==_MapKey.begin(). 00498 computeTCBKey(itPrev->second, it->second, itNext->second, 00499 itPrev->first, it->first, itNext->first, rangeDelta, it==_MapKey.begin(), itNext==_MapKey.begin(), getLoopMode()); 00500 00501 // Next key!! 00502 itPrev= it; 00503 it++; 00504 itNext++; 00505 // loop. 00506 if(itNext==_MapKey.end()) 00507 itNext= _MapKey.begin(); 00508 } 00509 00510 } |
|
compute TCB ease information.
Definition at line 56 of file track_tcb.h. Referenced by compile(), and CTrackKeyFramerTCB< CKeyT, T >::compile().
00057 { 00058 TMapTimeCKeyIterator it= mapKey.begin(); 00059 for(;it!=mapKey.end();it++) 00060 { 00061 TMapTimeCKeyIterator next= it; 00062 next++; 00063 00064 // loop mgt. must compute ease from last to first (usefull if _RangeLock is false). 00065 if(next==mapKey.end() && loopMode && mapKey.size()>1) 00066 next= mapKey.begin(); 00067 00068 // Ease Precompute. 00069 //================= 00070 CKeyT &key= it->second; 00071 if(next!=mapKey.end()) 00072 { 00073 float e0= it->second.EaseFrom; 00074 float e1= next->second.EaseTo; 00075 float s = e0 + e1; 00076 00077 // "normalize". 00078 if (s > 1.0f) 00079 { 00080 e0 = e0/s; 00081 e1 = e1/s; 00082 } 00083 00084 // precalc ease factors. 00085 key.Ease0= e0; 00086 key.Ease1= e1; 00087 key.EaseK= 1/(2.0f - e0 - e1); 00088 if(e0) 00089 key.EaseKOverEase0= key.EaseK / e0; 00090 if(e1) 00091 key.EaseKOverEase1= key.EaseK / e1; 00092 } 00093 else 00094 { 00095 // force ease() to just return d (see ease()). 00096 key.EaseK = 0.5f; 00097 } 00098 00099 } 00100 } |
|
Definition at line 121 of file track_tcb.h. Referenced by CTrackKeyFramerTCB< CKeyT, T >::evalKey().
00122 {
00123 float d2,d3,a;
00124
00125 d2 = d*d;
00126 d3 = d2*d;
00127 a = 3.0f*d2 - 2.0f*d3;
00128 hb[0] = 1.0f - a;
00129 hb[1] = a;
00130 hb[2] = d3 - 2.0f*d2 + d;
00131 hb[3] = d3 - d2;
00132 }
|
|
Definition at line 136 of file track_tcb.h. Referenced by computeTCBKey(), and CTrackKeyFramerTCB< CKeyT, T >::computeTCBKey().
00138 { 00139 float fp,fn; 00140 00141 if(isLoop || (!firstKey && !endKey)) 00142 { 00143 float dtm; 00144 // Compute Time deltas. 00145 if (firstKey) 00146 { 00147 dtm = 0.5f * (rangeDelta + timeAfter - time); 00148 fp = rangeDelta / dtm; 00149 fn = (timeAfter - time) / dtm; 00150 } 00151 else if (endKey) 00152 { 00153 dtm = 0.5f * (rangeDelta + time - timeBefore); 00154 fp = rangeDelta / dtm; 00155 fn = (time - timeBefore) / dtm; 00156 } 00157 else 00158 { 00159 dtm = 0.5f * (timeAfter - timeBefore); 00160 fp = (time - timeBefore) / dtm; 00161 fn = (timeAfter - time) / dtm; 00162 } 00163 float c= (float)fabs( key.Continuity ); 00164 fp = fp + c - c * fp; 00165 fn = fn + c - c * fn; 00166 } 00167 else 00168 { 00169 // firstkey and lastkey of not loop track. 00170 fp = 1.0f; 00171 fn = 1.0f; 00172 } 00173 00174 // Compute tangents factors. 00175 float tm,cm,cp,bm,bp,tmcm,tmcp; 00176 00177 cm = 1.0f - key.Continuity; 00178 tm = 0.5f * ( 1.0f - key.Tension ); 00179 cp = 2.0f - cm; 00180 bm = 1.0f - key.Bias; 00181 bp = 2.0f - bm; 00182 tmcm = tm*cm; tmcp = tm*cp; 00183 00184 // tgts factors. 00185 ksm = tmcm*bp*fp; ksp = tmcp*bm*fp; 00186 kdm = tmcp*bp*fn; kdp = tmcm*bm*fn; 00187 00188 } |
|
Definition at line 520 of file track_tcb.h. References CTCBTools< CKeyT, T, TMapTimeCKey >::computeTCBFactors().
00522 { 00523 CQuat qp, qm; 00524 00525 // compute qm. 00526 if (!firstKey || isLoop) 00527 { 00528 float angle= key.LocalAngleAxis.Angle; 00529 CVector &axis= key.LocalAngleAxis.Axis; 00530 00531 if (angle > 2*NLMISC::Pi- NLMISC::QuatEpsilon) 00532 { 00533 qm.set(axis.x, axis.y, axis.z, 0.0f); 00534 qm = qm.log(); 00535 } 00536 else 00537 { 00538 CQuat qprev= keyBefore.Quat; 00539 qprev.makeClosest(key.Quat); 00540 qm = CQuat::lnDif(qprev, key.Quat); 00541 } 00542 } 00543 00544 // compute qp. 00545 if (!endKey || isLoop) 00546 { 00547 float angle= keyAfter.LocalAngleAxis.Angle; 00548 CVector &axis= keyAfter.LocalAngleAxis.Axis; 00549 00550 if (angle > 2*NLMISC::Pi- NLMISC::QuatEpsilon) 00551 { 00552 qp.set(axis.x, axis.y, axis.z, 0.0f); 00553 qp = qp.log(); 00554 } 00555 else 00556 { 00557 CQuat qnext= keyAfter.Quat; 00558 qnext.makeClosest(key.Quat); 00559 qp = CQuat::lnDif(key.Quat, qnext); 00560 } 00561 } 00562 00563 // not loop mgt. 00564 if (firstKey && !isLoop) 00565 qm = qp; 00566 if (endKey && !isLoop) 00567 qp = qm; 00568 00569 00570 // compute tangents factors. 00571 float ksm, ksp, kdm, kdp; 00572 computeTCBFactors(key, timeBefore, time, timeAfter, rangeDelta, firstKey, endKey, isLoop, ksm,ksp,kdm,kdp); 00573 00574 00575 // A/B. 00576 CQuat qa, qb; 00577 qb= (qm * (1.0f-ksm) + qp * (-ksp) ) * 0.5f; 00578 qa= (qm * kdm + qp * (kdp-1.0f) ) * 0.5f; 00579 qa = qa.exp(); 00580 qb = qb.exp(); 00581 00582 key.A = key.Quat * qa; 00583 key.B = key.Quat * qb; 00584 } |
|
Definition at line 103 of file track_tcb.h. Referenced by evalKey(), and CTrackKeyFramerTCB< CKeyT, T >::evalKey().
00104 { 00105 if (d==0.0f || d==1.0f) return d; 00106 // k==0.5f <=> e0+e1 == 0. 00107 if (key->EaseK == 0.5f) return d; 00108 00109 if (d < key->Ease0) 00110 return key->EaseKOverEase0 * d*d; 00111 else if (d < 1.0f - key->Ease1) 00112 return key->EaseK * (2.0f*d - key->Ease0); 00113 else 00114 { 00115 d = 1.0f - d; 00116 return 1.0f - key->EaseKOverEase1 * d*d; 00117 } 00118 } |
|
evalKey (runtime).
Definition at line 401 of file track_tcb.h. References NLMISC::clamp(), and CTCBTools< CKeyT, T, TMapTimeCKey >::ease().
00404 { 00405 if(previous && next) 00406 { 00407 // lerp from previous to cur. 00408 date-= datePrevious; 00409 date*= previous->OODeltaTime; 00410 NLMISC::clamp(date, 0,1); 00411 00412 // ease. 00413 date = ease(previous, date); 00414 00415 // quad slerp. 00416 _Value.Value= CQuat::squadrev(next->LocalAngleAxis, previous->Quat, previous->A, next->B, next->Quat, date); 00417 } 00418 else 00419 { 00420 if (previous) 00421 _Value.Value= previous->Quat; 00422 else 00423 if (next) 00424 _Value.Value= next->Quat; 00425 } 00426 00427 } |
|
From ITrack.
Definition at line 392 of file track_tcb.h.
00393 { 00394 return _Value; 00395 } |
|
Definition at line 517 of file track_tcb.h. |