nel/src/3d/animation_playlist.cpp

   1 // NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
   2 // Copyright (C) 2010  Winch Gate Property Limited
   3 //
   4 // This program is free software: you can redistribute it and/or modify
   5 // it under the terms of the GNU Affero General Public License as
   6 // published by the Free Software Foundation, either version 3 of the
   7 // License, or (at your option) any later version.
   8 //
   9 // This program is distributed in the hope that it will be useful,
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 // GNU Affero General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Affero General Public License
  15 // along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16
  17 #include "std3d.h"
  18
  19 #include "nel/3d/animation_playlist.h"
  20 #include "nel/misc/common.h"
  21 #include "nel/misc/stream.h"
  22
  23 using namespace NLMISC;
  24
  25 #ifdef DEBUG_NEW
  26 #define new DEBUG_NEW
  27 #endif
  28
  29 namespace NL3D
  30 {
  31
  32 // ***************************************************************************
  33
  34 CAnimationPlaylist::CAnimationPlaylist()
  35 {
  36         // Empty the playlist
  37         emptyPlayList ();
  38
  39         // Set default wrap mode
  40         for (uint i=0; i<CChannelMixer::NumAnimationSlot; i++)
  41                 _WrapMode[i]=Clamp;
  42 }
  43
  44 // ***************************************************************************
  45
  46 void CAnimationPlaylist::emptyPlayList ()
  47 {
  48         // Empty each slot
  49         for (uint i=0; i<CChannelMixer::NumAnimationSlot; i++)
  50         {
  51                 _Animations[i]=empty;
  52                 _SkeletonWeight[i]=empty;
  53                 _InvertWeight[i]=false;
  54                 _TimeOrigin[i]=0.f;
  55                 _SpeedFactor[i]=1.f;
  56                 _StartWeight[i]=1.f;
  57                 _EndWeight[i]=1.f;
  58                 _StartWeightTime[i]= 0.f;
  59                 _EndWeightTime[i]= 0.f;
  60                 _Smoothness[i]= 0.f;
  61         }
  62 }
  63
  64 // ***************************************************************************
  65
  66 void CAnimationPlaylist::setAnimation (uint8 slot, uint animation)
  67 {
  68         _Animations[slot]=animation;
  69 }
  70
  71 // ***************************************************************************
  72
  73 uint CAnimationPlaylist::getAnimation (uint8 slot) const
  74 {
  75         return _Animations[slot];
  76 }
  77
  78 // ***************************************************************************
  79
  80 void CAnimationPlaylist::setSkeletonWeight (uint8 slot, uint skeletonId, bool inverted)
  81 {
  82         _SkeletonWeight[slot]=skeletonId;
  83         _InvertWeight[slot]=inverted;
  84 }
  85
  86 // ***************************************************************************
  87
  88 uint CAnimationPlaylist::getSkeletonWeight (uint8 slot, bool &inverted) const
  89 {
  90         inverted=_InvertWeight[slot];
  91         return _SkeletonWeight[slot];
  92 }
  93
  94 // ***************************************************************************
  95
  96 void CAnimationPlaylist::setTimeOrigin (uint8 slot, TGlobalAnimationTime timeOrigin)
  97 {
  98         _TimeOrigin[slot]=timeOrigin;
  99 }
 100
 101 // ***************************************************************************
 102
 103 TGlobalAnimationTime CAnimationPlaylist::getTimeOrigin (uint8 slot) const
 104 {
 105         return _TimeOrigin[slot];
 106 }
 107
 108 // ***************************************************************************
 109
 110 void CAnimationPlaylist::setSpeedFactor (uint8 slot, float speedFactor)
 111 {
 112         _SpeedFactor[slot]=speedFactor;
 113 }
 114
 115 // ***************************************************************************
 116
 117 float CAnimationPlaylist::getSpeedFactor (uint8 slot) const
 118 {
 119         return _SpeedFactor[slot];
 120 }
 121
 122 // ***************************************************************************
 123
 124 void CAnimationPlaylist::setStartWeight (uint8 slot, float startWeight, TGlobalAnimationTime time)
 125 {
 126         _StartWeight[slot]=startWeight;
 127         _StartWeightTime[slot]=time;
 128 }
 129
 130 // ***************************************************************************
 131
 132 float CAnimationPlaylist::getStartWeight (uint8 slot, TGlobalAnimationTime& time) const
 133 {
 134         time=_StartWeightTime[slot];
 135         return _StartWeight[slot];
 136 }
 137
 138 // ***************************************************************************
 139
 140 void CAnimationPlaylist::setEndWeight (uint8 slot, float endWeight, TGlobalAnimationTime time)
 141 {
 142         _EndWeight[slot]=endWeight;
 143         _EndWeightTime[slot]=time;
 144 }
 145
 146 // ***************************************************************************
 147
 148 float CAnimationPlaylist::getEndWeight (uint8 slot, TGlobalAnimationTime& time) const
 149 {
 150         time=_EndWeightTime[slot];
 151         return _EndWeight[slot];
 152 }
 153
 154 // ***************************************************************************
 155
 156 void CAnimationPlaylist::setWeightSmoothness (uint8 slot, float smoothness)
 157 {
 158         _Smoothness[slot]=smoothness;
 159 }
 160
 161 // ***************************************************************************
 162
 163 float CAnimationPlaylist::getWeightSmoothness (uint8 slot) const
 164 {
 165         return _Smoothness[slot];
 166 }
 167
 168 // ***************************************************************************
 169
 170 void CAnimationPlaylist::setupMixer (CChannelMixer& mixer, TGlobalAnimationTime time) const
 171 {
 172         // For each slot
 173         for (uint8 s=0; s<CChannelMixer::NumAnimationSlot; s++)
 174         {
 175                 // *** Set the time
 176
 177                 // Animation enabled
 178                 bool enabled=true;
 179
 180                 // Get the animationSet pointer from the mixer
 181                 const CAnimationSet *animSet=mixer.getAnimationSet ();
 182
 183                 // If is exists
 184                 if (animSet)
 185                 {
 186                         if (_Animations[s]!=empty)
 187                         {
 188                                 // Get the local time
 189                                 TAnimationTime wrappedTime = getLocalTime (s, time, *animSet);
 190
 191                                 // Get the animation
 192                                 const CAnimation *pAnimation=animSet->getAnimation (_Animations[s]);
 193
 194                                 // Disable mode ?
 195                                 if ((_WrapMode[s]==Disable)&&((wrappedTime<pAnimation->getBeginTime ())||(wrappedTime>pAnimation->getEndTime ())))
 196                                         enabled=false;
 197
 198                                 // Set the time
 199                                 if (enabled)
 200                                         mixer.setSlotTime (s, wrappedTime);
 201                         }
 202                 }
 203
 204                 // *** Set the animation
 205
 206                 // Still enabled
 207                 if (enabled)
 208                 {
 209                         // empty ?
 210                         if (_Animations[s]==empty)
 211                                 // Empty the slot
 212                                 mixer.emptySlot (s);
 213                         else
 214                                 // Set the animation id
 215                                 mixer.setSlotAnimation (s, _Animations[s]);
 216
 217                         // *** Set the skeleton weight
 218
 219                         // empty ?
 220                         if (_SkeletonWeight[s]==empty)
 221                                 // Empty the slot
 222                                 mixer.resetSkeletonWeight (s);
 223                         else
 224                                 // Set the animation id
 225                                 mixer.applySkeletonWeight (s, _SkeletonWeight[s],       _InvertWeight[s]);
 226
 227                         // *** Set the weight
 228                         mixer.setSlotWeight (s, getWeightValue (_StartWeightTime[s], _EndWeightTime[s], time, _StartWeight[s], _EndWeight[s], _Smoothness[s]));
 229                 }
 230                 else
 231                 {
 232                         // Disable this slot
 233                         mixer.emptySlot (s);
 234                 }
 235         }
 236 }
 237
 238 // ***************************************************************************
 239
 240 float CAnimationPlaylist::getWeightValue (TGlobalAnimationTime startWeightTime, TGlobalAnimationTime endWeightTime, TGlobalAnimationTime time, float startWeight, float endWeight, float smoothness)
 241 {
 242         // Clamp left
 243         if (time<=startWeightTime)
 244                 return startWeight;
 245         // Clamp left
 246         if (time>=endWeightTime)
 247                 return endWeight;
 248
 249         // *** Interpolate
 250
 251         // Linear value
 252         TGlobalAnimationTime linear=startWeight+(endWeight-startWeight)*(time-startWeightTime)/(endWeightTime-startWeightTime);
 253
 254         // Linear ?
 255         if (smoothness<0.0001f)
 256                 return (float)linear;
 257
 258         // Quadratic value
 259         double a=2.f*startWeight-2.f*endWeight;
 260         double b=3.f*endWeight-3.f*startWeight;
 261         double x=(time-startWeightTime)/(endWeightTime-startWeightTime);
 262         double xSquare=x*x;
 263         double xCube=x*xSquare;
 264         double quad=a*xCube+b*xSquare+startWeight;
 265
 266         // Interpolate between linear and quadratic
 267         return (float)(smoothness*quad+(1.f-smoothness)*linear);
 268 }
 269
 270 // ***************************************************************************
 271
 272 void CAnimationPlaylist::setWrapMode (uint8 slot, TWrapMode wrapMode)
 273 {
 274         _WrapMode[slot]=wrapMode;
 275 }
 276
 277 // ***************************************************************************
 278
 279 CAnimationPlaylist::TWrapMode CAnimationPlaylist::getWrapMode (uint8 slot) const
 280 {
 281         return _WrapMode[slot];
 282 }
 283
 284 // ***************************************************************************
 285
 286 void CAnimationPlaylist::serial (NLMISC::IStream& f)
 287 {
 288         // Serial a version
 289         (void)f.serialVersion (0);
 290
 291         // Serial all the values
 292         for (uint i=0; i<CChannelMixer::NumAnimationSlot; i++)
 293         {
 294                 f.serial (_Animations[i]);
 295                 f.serial (_SkeletonWeight[i]);
 296                 f.serial (_InvertWeight[i]);
 297                 f.serial (_TimeOrigin[i]);
 298                 f.serial (_SpeedFactor[i]);
 299                 f.serial (_StartWeight[i]);
 300                 f.serial (_StartWeightTime[i]);
 301                 f.serial (_EndWeight[i]);
 302                 f.serial (_EndWeightTime[i]);
 303                 f.serial (_Smoothness[i]);
 304                 f.serialEnum (_WrapMode[i]);
 305         }
 306 }
 307
 308 // ***************************************************************************
 309
 310 TAnimationTime CAnimationPlaylist::getLocalTime (uint8 slot, TGlobalAnimationTime globalTime, const CAnimationSet& animSet) const
 311 {
 312         // Get the animation
 313         const CAnimation *pAnimation=animSet.getAnimation (_Animations[slot]);
 314
 315         // If this animation exists
 316         if (pAnimation)
 317         {
 318                 // Compute the non-wrapped time
 319                 TAnimationTime wrappedTime=pAnimation->getBeginTime ()+(TAnimationTime)((globalTime-_TimeOrigin[slot])*_SpeedFactor[slot]);
 320
 321                 // Wrap mode
 322                 switch (_WrapMode[slot])
 323                 {
 324                 case Clamp:
 325                         clamp (wrappedTime, pAnimation->getBeginTime (), pAnimation->getEndTime ());
 326                         break;
 327                 case Repeat:
 328                         // Mod repeat the time
 329                         {
 330                                 float length=pAnimation->getEndTime ()-pAnimation->getBeginTime();
 331                                 if (wrappedTime>=pAnimation->getBeginTime())
 332                                         wrappedTime=pAnimation->getBeginTime()+(float)fmod (wrappedTime-pAnimation->getBeginTime(), length);
 333                                 else
 334                                         wrappedTime=pAnimation->getBeginTime()+(float)fmod (wrappedTime-pAnimation->getBeginTime(), length)+length;
 335                         }
 336                         break;
 337                         default: break;
 338                 }
 339
 340                 // Return localTime
 341                 return wrappedTime;
 342         }
 343
 344         return (TAnimationTime)globalTime;
 345 }
 346
 347 // ***************************************************************************
 348
 349 float CAnimationPlaylist::getLocalWeight (uint8 slot, TGlobalAnimationTime globalTime) const
 350 {
 351         return getWeightValue (_StartWeightTime[slot], _EndWeightTime[slot], globalTime, _StartWeight[slot], _EndWeight[slot], _Smoothness[slot]);
 352 }
 353
 354 // ***************************************************************************
 355
 356
 357 } // NL3D