NeL: NL3D::CTargetAnimCtrl class Reference

00063 {
+00064         // no op if req not met
+00065         if(!bone || !model || bone->getTransformMode()!=ITransformable::RotQuat)
+00066                 return;
+00067 
+00068         // If the user changed the Enabled state, must do a transition.
+00069         if(_LastEnabled!=Enabled)
+00070         {
+00071                 _LastEnabled= Enabled;
+00072                 // if re-enable the control while completely disabled before
+00073                 if(Enabled && !_EnableToDisableTransition)
+00074                 {
+00075                         // set the LastLSRotation so that it match the current anim ones.
+00076                         _LastLSRotation= getCurrentLSRotationFromBone(model, bone);
+00077                 }
+00078                 // if disable the ctrl, then do a transition first
+00079                 if(!Enabled)
+00080                 {
+00081                         _EnableToDisableTransition= true;
+00082                 }
+00083         }
+00084 
+00085         // If not enabled, and not in transition, no op.
+00086         if( !Enabled && !_EnableToDisableTransition)
+00087                 return;
+00088 
+00089         // If Target mode, compute CurrentWorldDirection
+00090         // ***********
+00091         // NB: does need to compute direction if disabled (even if in transition)
+00092         if(Mode==TargetMode && Enabled)
+00093         {
+00094                 // get the eye pos in world.
+00095                 CVector worldEye= bone->getWorldMatrix()*EyePos;
+00096                 // get the world dir
+00097                 CVector worldDir= (WorldTarget - worldEye).normed();
+00098                 // get the associated quat
+00099                 CMatrix mat;
+00100                 mat.setRot(CVector::I, worldDir, CVector::K);
+00101                 mat.normalize(CMatrix::YZX);
+00102                 CurrentWorldDirection= mat.getRot();
+00103         }
+00104 
+00105 
+00106         // compute rotation to apply In LocalSkeleton Space
+00107         // ***********
+00108         CQuat           currentLSRotation;
+00109 
+00110         /* Get the Skeleton default WorldMatrix (bind pos). used later
+00111                 TRICK: to get the default Skeleton WorldMatrix, get it from Bone[0] (ie "Bip01")
+00112                 We cannot use the Default Pos/Rot of the skeleton model because of export bug (not exported...)
+00113                 So, since Bip01 as no Local Rot (yes, its true, exporter report all Bip01 rots on Skeleton), 
+00114                 we are sure that Bip01 BindPos is the default Skeleton World Matrix.
+00115         */
+00116         CQuat           rootInvBP= model->Bones[0].getBoneBase().InvBindPos.getRot();
+00117 
+00118         // If ctrl not enabled, take the LSRotation from the animation
+00119         if(!Enabled)
+00120         {
+00121                 currentLSRotation= getCurrentLSRotationFromBone(model, bone);
+00122         }
+00123         else
+00124         {
+00125                 // Get the wanted direction in LocalSkeleton Space. 
+00126                 CQuat           currentLSDirection;
+00127 
+00128                 // Get the current wanted WorldDirection into LocalSkeleton space (hence using current skeleton WorldMatrix).
+00129                 CMatrix         toLSSpace= model->getWorldMatrix();
+00130                 currentLSDirection= toLSSpace.getRot().conjugate() * CurrentWorldDirection;
+00131 
+00132                 // Get the default WorldDirection into LocalSkeleton space (hence using default skeleton WorldMatrix).
+00133                 CQuat           defaultLSDirection= rootInvBP * DefaultWorldDirection;
+00134 
+00135                 /* get the rotation to apply to the bone when it is in bind Pos. If this quat is identity, 
+00136                         then the bone will be in default (or bind) pos.
+00137                         It is in essence the "rotation to apply to defaultDirection in LS space, in order to get 
+00138                         the wanted current direction in LS space".
+00139                         The makeClosest() is here just to ensure that the resulting angle<Pi (for clamp direction later)
+00140                 */
+00141                 currentLSDirection.makeClosest(defaultLSDirection);
+00142                 currentLSRotation= currentLSDirection * defaultLSDirection.conjugate();
+00143         }
+00144 
+00145 
+00146         // Clamp direction, and smooth direction changes.
+00147         // ***********
+00148         // if not enabled, then LSRotation comes from the animation => do not clamp
+00149         if(Enabled)
+00150         {
+00151                 // to AngleAxis.
+00152                 CAngleAxis      angleAxis= currentLSRotation.getAngleAxis();
+00153                 // Clamp the angle
+00154                 clamp(angleAxis.Angle, -MaxAngle, MaxAngle);
+00155                 // back To Quat.
+00156                 currentLSRotation.setAngleAxis(angleAxis);
+00157         }
+00158 
+00159         // get the dt of the scene.
+00160         CScene  *scene= model->getOwnerScene();
+00161         float   sceneDt= scene->getEllapsedTime();
+00162         float   maxDeltaAngle= MaxAngularVelocity*sceneDt;
+00163         // get the quat that change from LastRotation to CurrentRotation
+00164         CQuat   rotMod= _LastLSRotation.conjugate() * currentLSRotation;
+00165         // compute how many rotation we are allowed to do.
+00166         float   rotModAngle= (float)fabs(rotMod.getAngle());
+00167         bool    rotSpeedClamped= false;
+00168         if(rotModAngle)
+00169         {
+00170                 float   factor= (float)fabs(maxDeltaAngle) / rotModAngle;
+00171                 // If cannot do all the rotation this frame
+00172                 if(factor<1)
+00173                 {
+00174                         // then slerp between last and current rotation
+00175                         currentLSRotation.makeClosest(_LastLSRotation);
+00176                         currentLSRotation= CQuat::slerp(_LastLSRotation, currentLSRotation, factor);
+00177                         rotSpeedClamped= true;
+00178                 }
+00179         }
+00180 
+00181         // if the rotation has not been clamped for speed consideration, and if !Enabed, it's mean we have ended 
+00182         // the transition => no more compute next time
+00183         if(!Enabled && !rotSpeedClamped)
+00184                 _EnableToDisableTransition= false;
+00185 
+00186         // bkup last rotation
+00187         _LastLSRotation= currentLSRotation;
+00188 
+00189         // Apply the weighted Rotation to the bone
+00190         // ***********
+00191         // Get the bone Bind Pos in LocalSkeleton space (hence using Default Skeleton WorldMatrix)
+00192         CQuat   boneBindPosInWorld= bone->getBoneBase().InvBindPos.getRot().conjugate();
+00193         CQuat   boneBindPosInLS= rootInvBP * boneBindPosInWorld;
+00194         // rotate it to match our wanted direction.
+00195         boneBindPosInLS= currentLSRotation * boneBindPosInLS;
+00196 
+00197         // get it in bone local space.
+00198         // get the Bone Parent LocalSkeletonMatrix
+00199         CBone   *boneParent= bone->getFatherId()==-1? NULL : &model->Bones[bone->getFatherId()];
+00200         CQuat   currentLocalQuat;
+00201         if(!boneParent)
+00202                 currentLocalQuat= boneBindPosInLS;
+00203         else
+00204         {
+00205                 // compute the rotation to apply, in local space
+00206                 CQuat           qp= boneParent->getLocalSkeletonMatrix().getRot();
+00207                 currentLocalQuat= qp.conjugate() * boneBindPosInLS;
+00208         }
+00209 
+00210         // set the new LocalRotQuat
+00211         bone->setRotQuat(currentLocalQuat);
+00212         // and recompute the bone (but without AnimCtrl of course :) )
+00213         bone->compute(boneParent, model->getWorldMatrix(), NULL);
+00214 
+00215 }
+


Public Types
enum	TMode { TargetMode = 0, +DirectionMode, +NumMode + }
Public Member Functions
	CTargetAnimCtrl ()
	Constructor.
virtual void	execute (CSkeletonModel model, CBone bone)
	Called at compute() time.
virtual	~CTargetAnimCtrl ()
Data Fields
TMode	Mode
	Target controled or direction controled. Default to DirectionMode.
Target and Direction specific
CQuat	CurrentWorldDirection
	For DirectionMode, the WorldRotation to apply to the bone. NB: modified in execute() if TargetMode.
CVector	EyePos
	For TargetMode only, the Pos of eyes relative to the bone controlled. Default to (0,0,0).
CVector	WorldTarget
	For TargetMode, the world Position of the target.
Common
CQuat	DefaultWorldDirection
	This give The World Orientation when the Mesh is in bind Pos (default to "LookBack").
bool	Enabled
float	MaxAngle
	The Maximum angle of rotation that can be performed between the Default Direction and Current Direction. Default to Pi/3.
float	MaxAngularVelocity
	The Maximum Angular Velocity the ctrl can perform. Default to 2*Pi per second.
Private Member Functions
CQuat	getCurrentLSRotationFromBone (CSkeletonModel model, CBone bone)
Private Attributes
bool	_EnableToDisableTransition
bool	_LastEnabled
	This tells that a Enable/Disable transition is in progress.
CQuat	_LastLSRotation
	The last rotation computed (in LocalSkeleton Space). Used to smooth transition.

NL3D::CTargetAnimCtrl Class Reference

Detailed Description

Public Types

Public Member Functions

Data Fields

Private Member Functions

Private Attributes

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation