studio/src/plugins/object_viewer/scene/entity.cpp

   1 /*
   2     Object Viewer Qt
   3     Copyright (C) 2010 Dzmitry Kamiahin <dnk-88@tut.by>
   4
   5     This program is free software: you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation, either version 3 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program.  If not, see <http://www.gnu.org/licenses/>.
  17
  18 */
  19
  20 #include "stdpch.h"
  21 #include "entity.h"
  22
  23 #include <QtCore/QString>
  24
  25 // NeL includes
  26 #include <nel/misc/path.h>
  27 #include <nel/3d/u_driver.h>
  28 #include <nel/3d/u_scene.h>
  29 #include <nel/3d/u_animation_set.h>
  30 #include <nel/3d/u_animation.h>
  31 #include <nel/3d/u_play_list_manager.h>
  32 #include <nel/3d/u_play_list.h>
  33 #include <nel/3d/u_track.h>
  34
  35 // Project includes
  36 #include "modules.h"
  37
  38 using namespace NLMISC;
  39 using namespace NL3D;
  40
  41 namespace NLQT
  42 {
  43
  44 CSlotInfo::CSlotInfo()
  45         : Animation("empty"),
  46           Skeleton("empty"),
  47           Offset(0),
  48           StartTime(0),
  49           EndTime(0),
  50           StartBlend(1),
  51           EndBlend (1),
  52           Smoothness(1),
  53           SpeedFactor(1),
  54           ClampMode(0),
  55           SkeletonInverted(false),
  56           Enable(true)
  57 {
  58 }
  59
  60 CSlotInfo &CSlotInfo::operator=(const CSlotInfo &slotInfo)
  61 {
  62         if ( this != &slotInfo)
  63         {
  64                 Animation = slotInfo.Animation;
  65                 ClampMode = slotInfo.ClampMode;
  66                 Enable = slotInfo.Enable;
  67                 EndBlend = slotInfo.EndBlend;
  68                 EndTime = slotInfo.EndTime;
  69                 Offset = slotInfo.Offset;
  70                 Skeleton = slotInfo.Skeleton;
  71                 SkeletonInverted = slotInfo.SkeletonInverted;
  72                 Smoothness = slotInfo.Smoothness;
  73                 SpeedFactor = slotInfo.SpeedFactor;
  74                 StartBlend = slotInfo.StartBlend;
  75                 StartTime = slotInfo.StartTime;
  76         }
  77         return *this;
  78 }
  79
  80 CEntity::CEntity(void)
  81         : _Name("<Unknown>"),
  82           _FileNameShape(""),
  83           _FileNameSkeleton(""),
  84           _inPlace(false),
  85           _incPos(false),
  86           _Instance(NULL),
  87           _Skeleton(NULL),
  88           _PlayList(NULL),
  89           _AnimationSet(NULL)
  90 {
  91         _CharacterScalePos = 1;
  92 }
  93
  94 CEntity::~CEntity(void)
  95 {
  96         if (_PlayList != NULL)
  97         {
  98                 _PlayList->resetAllChannels();
  99                 Modules::objView().getPlayListManager()->deletePlayList (_PlayList);
 100                 _PlayList = NULL;
 101         }
 102         if (_AnimationSet != NULL)
 103         {
 104                 Modules::objView().getDriver()->deleteAnimationSet(_AnimationSet);
 105                 _AnimationSet = NULL;
 106         }
 107         if (!_Skeleton.empty())
 108         {
 109                 _Skeleton.detachSkeletonSon(_Instance);
 110                 Modules::objView().getScene()->deleteSkeleton(_Skeleton);
 111                 _Skeleton = NULL;
 112         }
 113         if (!_Instance.empty())
 114         {
 115                 Modules::objView().getScene()->deleteInstance(_Instance);
 116                 _Instance = NULL;
 117         }
 118 }
 119
 120 void CEntity::loadAnimation(const std::string &fileName)
 121 {
 122         uint id = _AnimationSet->addAnimation(fileName.c_str(),CFile::getFilenameWithoutExtension(fileName).c_str());
 123         _AnimationList.push_back(_AnimationSet->getAnimationName(id));
 124         _AnimationSet->build();
 125         if (!_Skeleton.empty())
 126                 _PlayList->registerTransform(_Skeleton);
 127         else
 128                 _PlayList->registerTransform(_Instance);
 129 }
 130
 131 void CEntity::loadSWT(const std::string &fileName)
 132 {
 133         uint id = _AnimationSet->addSkeletonWeight(fileName.c_str(),CFile::getFilenameWithoutExtension(fileName).c_str());
 134         _SWTList.push_back(_AnimationSet->getSkeletonWeightName(id));
 135 }
 136
 137 void CEntity::addAnimToPlayList(const std::string &name)
 138 {
 139         _PlayListAnimation.push_back(name);
 140
 141         _AnimationStatus.EndAnim = this->getPlayListLength();
 142
 143         _Instance.start();
 144 }
 145
 146 void CEntity::removeAnimToPlayList(uint row)
 147 {
 148         if (row < _PlayListAnimation.size())
 149                 _PlayListAnimation.erase(_PlayListAnimation.begin() + row);
 150
 151         _AnimationStatus.EndAnim = this->getPlayListLength();
 152 }
 153
 154 void CEntity::swapAnimToPlayList(uint row1, uint row2)
 155 {
 156         if ((row1 < _PlayListAnimation.size()) && (row2 < _PlayListAnimation.size()))
 157                 std::swap(_PlayListAnimation[row1], _PlayListAnimation[row2]);
 158 }
 159
 160 void CEntity::playbackAnim(bool play)
 161 {
 162         _AnimationStatus.PlayAnim = play;
 163
 164         if (play)
 165                 _Instance.start();
 166         else
 167                 _Instance.freezeHRC();
 168 }
 169
 170 void CEntity::reset()
 171 {
 172         _PlayListAnimation.clear();
 173         _AnimationList.clear();
 174         _SWTList.clear();
 175
 176         _PlayList->resetAllChannels();
 177 }
 178
 179 float CEntity::getPlayListLength() const
 180 {
 181         // Accumul all the time
 182         float time = 0;
 183         for(size_t i = 0; i < _PlayListAnimation.size(); ++i)
 184                 time += getAnimLength(_PlayListAnimation[i]);
 185         return time;
 186 }
 187
 188 float CEntity::getAnimLength(const std::string &name) const
 189 {
 190         uint id = _AnimationSet->getAnimationIdByName(name.c_str());
 191         NL3D::UAnimation *anim = _AnimationSet->getAnimation(id);
 192         return anim->getEndTime() - anim->getBeginTime();
 193 }
 194
 195 void CEntity::update(NL3D::TAnimationTime time)
 196 {
 197         this->resetChannel();
 198         switch (_AnimationStatus.Mode)
 199         {
 200         case Mode::PlayList:
 201                 animatePlayList(time);
 202                 break;
 203         case Mode::Mixer:
 204                 animateChannelMixer();
 205                 break;
 206         }
 207 }
 208
 209
 210 void CEntity::resetChannel()
 211 {
 212         for(uint i = 0; i < NL3D::CChannelMixer::NumAnimationSlot; ++i)
 213                 _PlayList->setAnimation(i, UPlayList::empty);
 214 }
 215
 216 void CEntity::addTransformation (CMatrix &current, UAnimation *anim, float begin, float end, UTrack *posTrack, UTrack *rotquatTrack,
 217                                                                  UTrack *nextPosTrack, UTrack *nextRotquatTrack, bool removeLast)
 218 {
 219         // In place ?
 220         if (_inPlace)
 221         {
 222                 // Just identity
 223                 current.identity();
 224         }
 225         else
 226         {
 227                 // Remove the start of the animation
 228                 CQuat rotEnd (0,0,0,1);
 229                 CVector posEnd (0,0,0);
 230                 if (rotquatTrack)
 231                 {
 232                         // Interpolate the rotation
 233                         rotquatTrack->interpolate (end, rotEnd);
 234                 }
 235                 if (posTrack)
 236                 {
 237                         // Interpolate the position
 238                         posTrack->interpolate (end, posEnd);
 239                 }
 240
 241                 // Add the final rotation and position
 242                 CMatrix tmp;
 243                 tmp.identity ();
 244                 tmp.setRot (rotEnd);
 245                 tmp.setPos (posEnd);
 246
 247                 // Incremental ?
 248                 if (_incPos)
 249                         current *= tmp;
 250                 else
 251                         current = tmp;
 252
 253                 if (removeLast)
 254                 {
 255                         CQuat rotStart (0,0,0,1);
 256                         CVector posStart (0,0,0);
 257                         if (nextRotquatTrack)
 258                         {
 259                                 // Interpolate the rotation
 260                                 nextRotquatTrack->interpolate (begin, rotStart);
 261                         }
 262                         if (nextPosTrack)
 263                         {
 264                                 // Interpolate the position
 265                                 nextPosTrack->interpolate (begin, posStart);
 266                         }
 267                         // Remove the init rotation and position of the next animation
 268                         tmp.identity ();
 269                         tmp.setRot (rotStart);
 270                         tmp.setPos (posStart);
 271                         tmp.invert ();
 272                         current *= tmp;
 273
 274                         // Normalize the mt
 275                         CVector I = current.getI ();
 276                         CVector J = current.getJ ();
 277                         I.z = 0;
 278                         J.z = 0;
 279                         J.normalize ();
 280                         CVector K = I^J;
 281                         K.normalize ();
 282                         I = J^K;
 283                         I.normalize ();
 284                         tmp.setRot (I, J, K);
 285                         tmp.setPos (current.getPos ());
 286                         current = tmp;
 287                 }
 288         }
 289 }
 290
 291 void CEntity::animatePlayList(NL3D::TAnimationTime time)
 292 {
 293         if (!_PlayListAnimation.empty())
 294         {
 295                 // Animation index
 296                 uint id = _AnimationSet->getAnimationIdByName(_PlayListAnimation[0].c_str());
 297
 298                 // Try channel AnimationSet
 299                 NL3D::UAnimation *anim = _AnimationSet->getAnimation(id);
 300
 301                 bool there = false;
 302
 303                 UTrack *posTrack = NULL;
 304                 UTrack *rotQuatTrack = NULL;
 305
 306                 // Current matrix
 307                 CMatrix current;
 308                 current.identity();
 309
 310                 // read an animation for init matrix
 311                 rotQuatTrack = anim->getTrackByName("rotquat");
 312                 posTrack = anim->getTrackByName("pos");
 313
 314                 there = posTrack || rotQuatTrack;
 315
 316                 // Accumul time
 317                 float startTime = 0;
 318                 float endTime = anim->getEndTime() - anim->getBeginTime();
 319
 320                 uint index = 0;
 321                 while (time >= endTime)
 322                 {
 323                         index++;
 324                         if (index < _PlayListAnimation.size())
 325                         {
 326                                 id = _AnimationSet->getAnimationIdByName(_PlayListAnimation[index].c_str());
 327                                 NL3D::UAnimation *newAnim = _AnimationSet->getAnimation(id);
 328
 329                                 UTrack *newPosTrack = newAnim->getTrackByName ("pos");
 330                                 UTrack *newRotquatTrack = newAnim->getTrackByName ("rotquat");
 331
 332                                 // Add the transformation
 333                                 addTransformation (current, anim, newAnim->getBeginTime(), anim->getEndTime(), posTrack, rotQuatTrack, newPosTrack, newRotquatTrack, true);
 334
 335
 336                                 anim = newAnim;
 337                                 posTrack = newPosTrack;
 338                                 rotQuatTrack = newRotquatTrack;
 339
 340                                 // Add start time
 341                                 startTime = endTime;
 342                                 endTime = startTime + (anim->getEndTime() - anim->getBeginTime());
 343                         }
 344                         else
 345                         {
 346                                 // Add the transformation
 347                                 addTransformation (current, anim, 0, anim->getEndTime(), posTrack, rotQuatTrack, NULL, NULL, false);
 348                                 break;
 349                         }
 350                 }
 351
 352                 // Time cropped ?
 353                 if (index >= _PlayListAnimation.size())
 354                 {
 355                         // Yes
 356                         index--;
 357                         id = _AnimationSet->getAnimationIdByName(_PlayListAnimation[index].c_str());
 358                         anim = _AnimationSet->getAnimation(id);
 359
 360                         // End time for last anim
 361                         startTime = anim->getEndTime() - time;
 362                 }
 363                 else
 364                 {
 365                         // No
 366
 367                         // Add the transformation
 368                         addTransformation (current, anim, 0, anim->getBeginTime() + time - startTime, posTrack, rotQuatTrack, NULL, NULL, false);
 369
 370                         id = _AnimationSet->getAnimationIdByName(_PlayListAnimation[index].c_str());
 371                         anim = _AnimationSet->getAnimation(id);
 372
 373                         // Final time
 374                         startTime -= anim->getBeginTime();
 375                 }
 376
 377                 // Set the slot
 378                 _PlayList->setAnimation(0, id);
 379                 _PlayList->setTimeOrigin(0, startTime);
 380                 _PlayList->setSpeedFactor(0, 1.0f);
 381                 _PlayList->setWeightSmoothness(0, 1.0f);
 382                 _PlayList->setStartWeight(0, 1, 0);
 383                 _PlayList->setEndWeight(0, 1, 1);
 384                 _PlayList->setWrapMode(0, UPlayList::Clamp);
 385
 386                 // Setup the pos and rot for this shape
 387                 if (there)
 388                 {
 389                         CVector pos = current.getPos();
 390
 391                         // If a  skeleton model
 392                         if(!_Skeleton.empty())
 393                         {
 394                                 _Skeleton.setTransformMode(NL3D::UTransformable::RotQuat);
 395                                 // scale animated pos value with the CFG scale
 396                                 pos *= _CharacterScalePos;
 397                                 _Skeleton.setPos(pos);
 398                                 _Skeleton.setRotQuat(current.getRot());
 399                         }
 400                         else
 401                         {
 402                                 _Instance.setTransformMode(NL3D::UTransformable::RotQuat);
 403                                 _Instance.setPos(pos);
 404                                 _Instance.setRotQuat(current.getRot());
 405                         }
 406                 }
 407         }
 408 }
 409
 410 void CEntity::animateChannelMixer()
 411 {
 412         for (uint i = 0; i < NL3D::CChannelMixer::NumAnimationSlot; ++i)
 413         {
 414                 if (_SlotInfo[i].Enable)
 415                 {
 416                         // Set the animation
 417                         uint animId =  _AnimationSet->getAnimationIdByName(_SlotInfo[i].Animation);
 418                         if (animId == UAnimationSet::NotFound)
 419                                 _PlayList->setAnimation(i, UPlayList::empty);
 420                         else
 421                                 _PlayList->setAnimation(i, animId);
 422
 423                         // Set the skeleton weight
 424                         uint skelId = _AnimationSet->getSkeletonWeightIdByName(_SlotInfo[i].Skeleton);
 425                         if (skelId == UAnimationSet::NotFound)
 426                                 _PlayList->setSkeletonWeight(i, UPlayList::empty, false);
 427                         else
 428                                 _PlayList->setSkeletonWeight(i, skelId, _SlotInfo[i].SkeletonInverted);
 429
 430                         // Set others values
 431                         _PlayList->setTimeOrigin(i, _SlotInfo[i].Offset);
 432                         _PlayList->setSpeedFactor(i, _SlotInfo[i].SpeedFactor);
 433                         _PlayList->setStartWeight(i, _SlotInfo[i].StartBlend, _SlotInfo[i].StartTime);
 434                         _PlayList->setEndWeight(i, _SlotInfo[i].EndBlend, _SlotInfo[i].EndTime);
 435                         _PlayList->setWeightSmoothness(i, _SlotInfo[i].Smoothness);
 436
 437                         // Switch between wrap modes
 438                         switch (_SlotInfo[i].ClampMode)
 439                         {
 440                         case 0:
 441                                 _PlayList->setWrapMode (i, UPlayList::Clamp);
 442                                 break;
 443                         case 1:
 444                                 _PlayList->setWrapMode (i, UPlayList::Repeat);
 445                                 break;
 446                         case 2:
 447                                 _PlayList->setWrapMode (i, UPlayList::Disable);
 448                                 break;
 449                         }
 450                 }
 451         }
 452 }
 453
 454 } /* namespace NLQT */