Libs/Models/AnimExpr.cpp

   1 /*
   2 Cafu Engine, http://www.cafu.de/
   3 Copyright (c) Carsten Fuchs and other contributors.
   4 This project is licensed under the terms of the MIT license.
   5 */
   6
   7 #include "AnimExpr.hpp"
   8 #include "Model_cmdl.hpp"
   9
  10
  11 AnimExpressionT::AnimExpressionT(const CafuModelT& Model)
  12     : m_Model(Model),
  13       m_RefCount(0)
  14 {
  15 }
  16
  17
  18 /*************************/
  19 /*** AnimExprStandardT ***/
  20 /*************************/
  21
  22 AnimExprStandardT::AnimExprStandardT(const CafuModelT& Model, int SequNr, float FrameNr)
  23     : AnimExpressionT(Model),
  24       m_SequNr(SequNr),
  25       m_FrameNr(FrameNr),
  26       m_ForceLoop(false)
  27 {
  28     NormalizeInput();
  29 }
  30
  31
  32 void AnimExprStandardT::GetData(unsigned int JointNr, float& Weight, Vector3fT& Pos, cf::math::QuaternionfT& Quat, Vector3fT& Scale) const
  33 {
  34     typedef CafuModelT::JointT JointT;
  35     typedef CafuModelT::AnimT  AnimT;
  36
  37     const ArrayT<JointT>& Joints=GetModel().GetJoints();
  38     const ArrayT<AnimT>&  Anims =GetModel().GetAnims();
  39
  40     if (m_SequNr==-1)
  41     {
  42         // Don't animate, just use the bind pose defined in the model file.
  43         const JointT& J=Joints[JointNr];
  44
  45         Weight=1.0f;
  46         Pos   =J.Pos;
  47         Quat  =cf::math::QuaternionfT::FromXYZ(J.Qtr);
  48         Scale =J.Scale;
  49     }
  50     else
  51     {
  52         // m_SequNr is a valid index into Anims -- use it.
  53         const AnimT& Anim=Anims[m_SequNr];
  54         const int    Frame_0=int(m_FrameNr);                        // If m_FrameNr == 17.83, then Frame_0 == 17
  55         const float  Frame_f=m_FrameNr-Frame_0;                     //                             Frame_f ==  0.83
  56         const int    Frame_1=(Frame_0+1) % int(Anim.Frames.Size()); //                             Frame_1 == 18
  57
  58         const AnimT::AnimJointT& AJ=Anim.AnimJoints[JointNr];
  59
  60         Vector3fT Data_0[3]={ AJ.DefaultPos, AJ.DefaultQtr, AJ.DefaultScale };
  61         Vector3fT Data_1[3]={ AJ.DefaultPos, AJ.DefaultQtr, AJ.DefaultScale };
  62
  63         // Determine the position, quaternion and scale for Frame_0 and Frame_1.
  64         unsigned int FlagCount=0;
  65
  66         for (int i=0; i<9; i++)
  67         {
  68             if ((AJ.Flags >> i) & 1)
  69             {
  70                 Data_0[i/3][i % 3]=Anim.Frames[Frame_0].AnimData[AJ.FirstDataIdx+FlagCount];
  71                 Data_1[i/3][i % 3]=Anim.Frames[Frame_1].AnimData[AJ.FirstDataIdx+FlagCount];
  72
  73                 FlagCount++;
  74             }
  75         }
  76
  77         if (Frame_1==0 && Frame_f<0.001f)
  78         {
  79             // This is most likely the end of a non-wrapping sequence.
  80             Weight=1.0f;
  81             Pos   =Data_0[0];
  82             Quat  =cf::math::QuaternionfT::FromXYZ(Data_0[1]);
  83             Scale =Data_0[2];
  84         }
  85         else
  86         {
  87             // Interpolate the position and quaternion according to the fraction Frame_f.
  88             Weight=1.0f;
  89             Pos   =Data_0[0]*(1.0f-Frame_f) + Data_1[0]*Frame_f;
  90             Quat  =slerp(cf::math::QuaternionfT::FromXYZ(Data_0[1]), cf::math::QuaternionfT::FromXYZ(Data_1[1]), Frame_f);
  91             Scale =Data_0[2]*(1.0f-Frame_f) + Data_1[2]*Frame_f;
  92         }
  93     }
  94 }
  95
  96
  97 bool AnimExprStandardT::AdvanceTime(float Time)
  98 {
  99     const ArrayT<CafuModelT::AnimT>& Anims = GetModel().GetAnims();
 100
 101     if (m_SequNr < 0 || m_SequNr >= int(Anims.Size())) { SetFrameNr(0.0f); return false; }
 102     if (Anims[m_SequNr].Frames.Size() <= 1) { SetFrameNr(0.0f); return false; }
 103
 104     const float NumFrames = float(Anims[m_SequNr].Frames.Size());
 105     const int   Next      = m_ForceLoop ? m_SequNr : Anims[m_SequNr].Next;
 106     float       FrameNr   = m_FrameNr + Time*Anims[m_SequNr].FPS;
 107     bool        Wrapped   = false;
 108
 109     if (Next < 0)
 110     {
 111         // This is a play-once (non-repeating) sequence, there is no "next" sequence.
 112         // Thus clamp the frame number to NumFrames-1.
 113         if (FrameNr >= NumFrames - 1.0f)
 114         {
 115             FrameNr = NumFrames - 1.0f;
 116             if (m_FrameNr < FrameNr) Wrapped = true;
 117         }
 118     }
 119     else
 120     {
 121         // There is a "next" sequence following this.
 122         if (FrameNr >= NumFrames)
 123         {
 124             FrameNr -= NumFrames;
 125             Wrapped = true;
 126
 127             /* Calling SetSequNr(Next) below would technically be the right thing to do to
 128              * progress to the next sequence.
 129              * However, this is not supported in AnimExprStandardT for several reasons:
 130              *   - Backwards-compatibility. See class documentation for details.
 131              *   - Requires changes to GetData(). The implementation as-is is not sufficient.
 132              */
 133             // SetSequNr(Next);
 134         }
 135     }
 136
 137     SetFrameNr(FrameNr);
 138     return Wrapped;
 139 }
 140
 141
 142 AnimExpressionPtrT AnimExprStandardT::Clone() const
 143 {
 144     IntrusivePtrT<AnimExprStandardT> StdAE=GetModel().GetAnimExprPool().GetStandard(m_SequNr, m_FrameNr);
 145
 146     StdAE->SetForceLoop(m_ForceLoop);
 147     return StdAE;
 148 }
 149
 150
 151 bool AnimExprStandardT::IsEqual(const AnimExpressionPtrT& AE) const
 152 {
 153     AnimExprStandardT* Other=dynamic_cast<AnimExprStandardT*>(AE.get());
 154
 155     if (!Other) return false;
 156     return m_SequNr==Other->m_SequNr && m_FrameNr==Other->m_FrameNr && m_ForceLoop==Other->m_ForceLoop;
 157 }
 158
 159
 160 void AnimExprStandardT::SetSequNr(int SequNr)
 161 {
 162     if (m_SequNr==SequNr) return;
 163
 164     m_SequNr=SequNr;
 165     NormalizeInput();
 166 }
 167
 168
 169 void AnimExprStandardT::SetFrameNr(float FrameNr)
 170 {
 171     if (m_FrameNr==FrameNr) return;
 172
 173     m_FrameNr=FrameNr;
 174     NormalizeInput();
 175 }
 176
 177
 178 void AnimExprStandardT::SetForceLoop(bool ForceLoop)
 179 {
 180     m_ForceLoop=ForceLoop;
 181 }
 182
 183
 184 void AnimExprStandardT::NormalizeInput()
 185 {
 186     const ArrayT<CafuModelT::AnimT>& Anims=GetModel().GetAnims();
 187
 188     // m_SequNr==-1 means "use the bind pose from the model file only (no anim)".
 189     if (m_SequNr < -1) m_SequNr = -1;
 190     if (m_SequNr >= int(Anims.Size())) m_SequNr = -1;
 191     if (m_SequNr != -1 && (Anims[m_SequNr].FPS<0.0 || Anims[m_SequNr].Frames.Size()==0)) m_SequNr = -1;
 192
 193     m_FrameNr=std::max(m_FrameNr, 0.0f);
 194     m_FrameNr=(m_SequNr==-1) ? 0.0f : fmod(m_FrameNr, float(Anims[m_SequNr].Frames.Size()));
 195 }
 196
 197
 198 /***********************/
 199 /*** AnimExprFilterT ***/
 200 /***********************/
 201
 202 namespace
 203 {
 204     unsigned int FindChannelByName(const CafuModelT& Model, const std::string& ChannelName)
 205     {
 206         unsigned int ChannelNr;
 207
 208         for (ChannelNr=0; ChannelNr<Model.GetChannels().Size(); ChannelNr++)
 209             if (ChannelName == Model.GetChannels()[ChannelNr].Name)
 210                 return ChannelNr;
 211
 212         return ChannelNr;
 213     }
 214 }
 215
 216
 217 AnimExprFilterT::AnimExprFilterT(const CafuModelT& Model, AnimExpressionPtrT SubExpr, unsigned int ChannelNr)
 218     : AnimExpressionT(Model),
 219       m_SubExpr(SubExpr),
 220       m_ChannelNr(ChannelNr)
 221 {
 222 }
 223
 224
 225 AnimExprFilterT::AnimExprFilterT(const CafuModelT& Model, AnimExpressionPtrT SubExpr, const std::string& ChannelName)
 226     : AnimExpressionT(Model),
 227       m_SubExpr(SubExpr),
 228       m_ChannelNr(FindChannelByName(Model, ChannelName))
 229 {
 230 }
 231
 232
 233 void AnimExprFilterT::ReInit(AnimExpressionPtrT SubExpr, unsigned int ChannelNr)
 234 {
 235     if (m_SubExpr==SubExpr && m_ChannelNr==ChannelNr) return;
 236
 237     m_SubExpr  =SubExpr;
 238     m_ChannelNr=ChannelNr;
 239 }
 240
 241
 242 void AnimExprFilterT::GetData(unsigned int JointNr, float& Weight, Vector3fT& Pos, cf::math::QuaternionfT& Quat, Vector3fT& Scale) const
 243 {
 244     Weight=0.0f;
 245
 246     if (m_ChannelNr >= GetModel().GetChannels().Size() || GetModel().GetChannels()[m_ChannelNr].IsMember(JointNr))
 247     {
 248         m_SubExpr->GetData(JointNr, Weight, Pos, Quat, Scale);
 249     }
 250 }
 251
 252
 253 AnimExpressionPtrT AnimExprFilterT::Clone() const
 254 {
 255     return GetModel().GetAnimExprPool().GetFilter(m_SubExpr->Clone(), m_ChannelNr);
 256 }
 257
 258
 259 bool AnimExprFilterT::IsEqual(const AnimExpressionPtrT& AE) const
 260 {
 261     AnimExprFilterT* Other=dynamic_cast<AnimExprFilterT*>(AE.get());
 262
 263     if (!Other) return false;
 264     return m_ChannelNr==Other->m_ChannelNr && m_SubExpr->IsEqual(Other->m_SubExpr);
 265 }
 266
 267
 268 /************************/
 269 /*** AnimExprCombineT ***/
 270 /************************/
 271
 272 AnimExprCombineT::AnimExprCombineT(const CafuModelT& Model, AnimExpressionPtrT A, AnimExpressionPtrT B)
 273     : AnimExpressionT(Model),
 274       m_A(A),
 275       m_B(B)
 276 {
 277 }
 278
 279
 280 void AnimExprCombineT::ReInit(AnimExpressionPtrT A, AnimExpressionPtrT B)
 281 {
 282     if (m_A==A && m_B==B) return;
 283
 284     m_A=A;
 285     m_B=B;
 286 }
 287
 288
 289 void AnimExprCombineT::GetData(unsigned int JointNr, float& Weight, Vector3fT& Pos, cf::math::QuaternionfT& Quat, Vector3fT& Scale) const
 290 {
 291     m_A->GetData(JointNr, Weight, Pos, Quat, Scale);
 292
 293     float                  WeightB;
 294     Vector3fT              PosB;
 295     cf::math::QuaternionfT QuatB;
 296     Vector3fT              ScaleB;
 297
 298     // Pick the expression with the largest weight.
 299     m_B->GetData(JointNr, WeightB, PosB, QuatB, ScaleB);
 300
 301     if (WeightB > Weight)
 302     {
 303         Weight = WeightB;
 304         Pos    = PosB;
 305         Quat   = QuatB;
 306         Scale  = ScaleB;
 307     }
 308 }
 309
 310
 311 bool AnimExprCombineT::AdvanceTime(float Time)
 312 {
 313     const bool WrapA = m_A->AdvanceTime(Time);
 314     const bool WrapB = m_B->AdvanceTime(Time);
 315
 316     return WrapA || WrapB;
 317 }
 318
 319
 320 AnimExpressionPtrT AnimExprCombineT::Clone() const
 321 {
 322     return GetModel().GetAnimExprPool().GetCombine(m_A->Clone(), m_B->Clone());
 323 }
 324
 325
 326 bool AnimExprCombineT::IsEqual(const AnimExpressionPtrT& AE) const
 327 {
 328     AnimExprCombineT* Other=dynamic_cast<AnimExprCombineT*>(AE.get());
 329
 330     if (!Other) return false;
 331     return m_A->IsEqual(Other->m_A) && m_B->IsEqual(Other->m_B);
 332 }
 333
 334
 335 /**********************/
 336 /*** AnimExprBlendT ***/
 337 /**********************/
 338
 339 AnimExprBlendT::AnimExprBlendT(const CafuModelT& Model, AnimExpressionPtrT A, AnimExpressionPtrT B, float Duration)
 340     : AnimExpressionT(Model),
 341       m_A(A),
 342       m_B(B),
 343       m_Duration(Duration),
 344       m_Frac(0.0f)
 345 {
 346 }
 347
 348
 349 void AnimExprBlendT::ReInit(AnimExpressionPtrT A, AnimExpressionPtrT B, float Duration)
 350 {
 351     m_A=A;
 352     m_B=B;
 353     m_Duration=Duration;
 354     m_Frac=0.0f;
 355 }
 356
 357
 358 void AnimExprBlendT::GetData(unsigned int JointNr, float& Weight, Vector3fT& Pos, cf::math::QuaternionfT& Quat, Vector3fT& Scale) const
 359 {
 360     float                  w[2];
 361     Vector3fT              p[2];
 362     cf::math::QuaternionfT q[2];
 363     Vector3fT              s[2];
 364
 365     if (m_Frac <= 0.0f)
 366     {
 367         m_A->GetData(JointNr, Weight, Pos, Quat, Scale);
 368         return;
 369     }
 370
 371     if (m_Frac >= 1.0f)
 372     {
 373         m_B->GetData(JointNr, Weight, Pos, Quat, Scale);
 374         return;
 375     }
 376
 377     m_A->GetData(JointNr, w[0], p[0], q[0], s[0]);
 378     m_B->GetData(JointNr, w[1], p[1], q[1], s[1]);
 379
 380     const float f0 = 1.0f - m_Frac;
 381     const float f1 = m_Frac;
 382
 383     Weight = w[0]*f0 + w[1]*f1;
 384     Pos    = p[0]*f0 + p[1]*f1;
 385     Quat   = slerp(q[0], q[1], f1);   // slerp() is why we cannot have generic "add" and "mul" AnimExpressionT's.
 386     Scale  = s[0]*f0 + s[1]*f1;
 387 }
 388
 389
 390 bool AnimExprBlendT::AdvanceTime(float Time)
 391 {
 392     // Advance the blend fraction.
 393     if (m_Duration < 0.001f)
 394     {
 395         m_Frac = 1.0f;
 396     }
 397     else
 398     {
 399         m_Frac += Time/m_Duration;
 400     }
 401
 402     m_Frac = std::min(m_Frac, 1.0f);
 403
 404
 405     // Advance the sub-expressions.
 406     if (m_Frac < 1.0f)
 407     {
 408         m_A->AdvanceTime(Time);
 409     }
 410     else
 411     {
 412         m_A=NULL;   // m_A is unused now that m_Frac >= 1.0.
 413     }
 414
 415     return m_B->AdvanceTime(Time);
 416 }
 417
 418
 419 AnimExpressionPtrT AnimExprBlendT::Clone() const
 420 {
 421     IntrusivePtrT<AnimExprBlendT> Blend=GetModel().GetAnimExprPool().GetBlend(
 422         m_A==NULL ? NULL : m_A->Clone(), m_B->Clone(), m_Duration);
 423
 424     Blend->m_Frac=m_Frac;
 425     return Blend;
 426 }
 427
 428
 429 bool AnimExprBlendT::IsEqual(const AnimExpressionPtrT& AE) const
 430 {
 431     AnimExprBlendT* Other=dynamic_cast<AnimExprBlendT*>(AE.get());
 432
 433     if (!Other) return false;
 434     return m_Frac==Other->m_Frac && m_Duration==Other->m_Duration &&
 435            m_B->IsEqual(Other->m_B) &&
 436            (m_A==NULL ? Other->m_A==NULL : m_A->IsEqual(Other->m_A));
 437 }
 438
 439
 440 /*********************/
 441 /*** AnimExprPoolT ***/
 442 /*********************/
 443
 444 void AnimExprPoolT::FlattenUnused()
 445 {
 446     for (unsigned int AENr=0; AENr<m_Filter.Size(); AENr++)
 447         if (m_Filter[AENr]->GetRefCount()==1)
 448             m_Filter[AENr]->ReInit(NULL, 0);
 449
 450     for (unsigned int AENr=0; AENr<m_Combine.Size(); AENr++)
 451         if (m_Combine[AENr]->GetRefCount()==1)
 452             m_Combine[AENr]->ReInit(NULL, NULL);
 453
 454     for (unsigned int AENr=0; AENr<m_Blend.Size(); AENr++)
 455         if (m_Blend[AENr]->GetRefCount()==1)
 456             m_Blend[AENr]->ReInit(NULL, NULL, 0.0f);
 457 }
 458
 459
 460 IntrusivePtrT<AnimExprStandardT> AnimExprPoolT::GetStandard(int SequNr, float FrameNr)
 461 {
 462     FlattenUnused();
 463
 464     for (unsigned int AENr=0; AENr<m_Standard.Size(); AENr++)
 465     {
 466         if (m_Standard[AENr]->GetRefCount()==1)
 467         {
 468             m_Standard[AENr]->SetSequNr(SequNr);
 469             m_Standard[AENr]->SetFrameNr(FrameNr);
 470             m_Standard[AENr]->SetForceLoop(false);
 471
 472             return m_Standard[AENr];
 473         }
 474     }
 475
 476     IntrusivePtrT<AnimExprStandardT> NewAE(new AnimExprStandardT(m_Model, SequNr, FrameNr));
 477     m_Standard.PushBack(NewAE);
 478
 479     return NewAE;
 480 }
 481
 482
 483 IntrusivePtrT<AnimExprFilterT> AnimExprPoolT::GetFilter(AnimExpressionPtrT SubExpr, unsigned int ChannelNr)
 484 {
 485     FlattenUnused();
 486
 487     for (unsigned int AENr=0; AENr<m_Filter.Size(); AENr++)
 488     {
 489         if (m_Filter[AENr]->GetRefCount()==1)
 490         {
 491             m_Filter[AENr]->ReInit(SubExpr, ChannelNr);
 492
 493             return m_Filter[AENr];
 494         }
 495     }
 496
 497     IntrusivePtrT<AnimExprFilterT> NewAE(new AnimExprFilterT(m_Model, SubExpr, ChannelNr));
 498     m_Filter.PushBack(NewAE);
 499
 500     return NewAE;
 501 }
 502
 503
 504 IntrusivePtrT<AnimExprFilterT> AnimExprPoolT::GetFilter(AnimExpressionPtrT SubExpr, const std::string& ChannelName)
 505 {
 506     return GetFilter(SubExpr, FindChannelByName(m_Model, ChannelName));
 507 }
 508
 509
 510 IntrusivePtrT<AnimExprCombineT> AnimExprPoolT::GetCombine(AnimExpressionPtrT A, AnimExpressionPtrT B)
 511 {
 512     FlattenUnused();
 513
 514     for (unsigned int AENr=0; AENr<m_Combine.Size(); AENr++)
 515     {
 516         if (m_Combine[AENr]->GetRefCount()==1)
 517         {
 518             m_Combine[AENr]->ReInit(A, B);
 519
 520             return m_Combine[AENr];
 521         }
 522     }
 523
 524     IntrusivePtrT<AnimExprCombineT> NewAE(new AnimExprCombineT(m_Model, A, B));
 525     m_Combine.PushBack(NewAE);
 526
 527     return NewAE;
 528 }
 529
 530
 531 IntrusivePtrT<AnimExprBlendT> AnimExprPoolT::GetBlend(AnimExpressionPtrT A, AnimExpressionPtrT B, float Duration)
 532 {
 533     FlattenUnused();
 534
 535     for (unsigned int AENr=0; AENr<m_Blend.Size(); AENr++)
 536     {
 537         if (m_Blend[AENr]->GetRefCount()==1)
 538         {
 539             m_Blend[AENr]->ReInit(A, B, Duration);
 540
 541             return m_Blend[AENr];
 542         }
 543     }
 544
 545     IntrusivePtrT<AnimExprBlendT> NewAE(new AnimExprBlendT(m_Model, A, B, Duration));
 546     m_Blend.PushBack(NewAE);
 547
 548     return NewAE;
 549 }