Code/Sandbox/Plugins/EditorTrackView/AnimationContext.cpp

   1 // Copyright 2001-2018 Crytek GmbH / Crytek Group. All rights reserved.
   2
   3 #include "StdAfx.h"
   4 #include "AnimationContext.h"
   5
   6 #include "Objects/SelectionGroup.h"
   7 #include "Objects/EntityObject.h"
   8 #include "Objects/ObjectManager.h"
   9 #include "Nodes/TrackViewSequence.h"
  10 #include "Animators/CommentNodeAnimator.h"
  11
  12 #include "RenderViewport.h"
  13 #include "Viewport.h"
  14 #include "ViewManager.h"
  15 #include "IPostRenderer.h"
  16 #include "TrackViewPlugin.h"
  17
  18 #include <CryMovie/IMovieSystem.h>
  19 #include <CrySystem/ITimer.h>
  20
  21 class CMovieCallback : public IMovieCallback, public ICameraDelegate
  22 {
  23 public:
  24         CMovieCallback() : m_cameraObjectGUID(CryGUID::Null()) {}
  25         void OnSetCamera(const SCameraParams& cameraParams)
  26         {
  27                 CEntityObject* pEditorEntity = CEntityObject::FindFromEntityId(cameraParams.cameraEntityId);
  28                 if (pEditorEntity)
  29                 {
  30                         m_cameraObjectGUID = pEditorEntity->GetId();
  31                 }
  32                 else
  33                 {
  34                         m_cameraObjectGUID = CryGUID::Null();
  35                 }
  36         };
  37
  38         void ResetCamera()
  39         {
  40                 m_cameraObjectGUID = CryGUID::Null();
  41         }
  42
  43         virtual CryGUID GetActiveCameraObjectGUID() const
  44         {
  45                 return m_cameraObjectGUID;
  46         }
  47
  48         virtual const char* GetName() const
  49         {
  50                 return "TrackView";
  51         }
  52
  53 private:
  54         CryGUID m_cameraObjectGUID;
  55 };
  56
  57 static CMovieCallback s_movieCallback;
  58
  59 class CAnimationContextPostRender : public IPostRenderer
  60 {
  61 public:
  62         CAnimationContextPostRender(CAnimationContext* pAC)
  63                 : m_pAC(pAC)
  64         {
  65         }
  66
  67         void OnPostRender() const { assert(m_pAC); m_pAC->OnPostRender(); }
  68
  69 protected:
  70         CAnimationContext* m_pAC;
  71 };
  72
  73 CAnimationContext::CAnimationContext()
  74 {
  75         m_bPlaying = false;
  76         m_bPaused = false;
  77         m_bRecording = false;
  78         m_bSavedRecordingState = false;
  79         m_timeRange.Set(SAnimTime(0.0f), SAnimTime(0.0f));
  80         m_playbackRange.Set(SAnimTime(0.0f), SAnimTime(0.0f));
  81         m_currTime = SAnimTime(0.0f);
  82         m_bForceUpdateInNextFrame = false;
  83         m_fTimeScale = 1.0f;
  84         m_pSequence = nullptr;
  85         m_bLooping = false;
  86         m_bAutoRecording = false;
  87         m_recordingTimeStep = SAnimTime(0.0f);
  88         m_bSingleFrame = false;
  89         m_bPostRenderRegistered = false;
  90         m_bWasRecording = false;
  91
  92         GetIEditor()->GetIUndoManager()->AddListener(this);
  93         CTrackViewPlugin::GetSequenceManager()->AddListener(this);
  94         GetIEditor()->RegisterNotifyListener(this);
  95         GetIEditor()->GetGameEngine()->AddListener(this);
  96         GetIEditor()->GetViewManager()->RegisterCameraDelegate(&s_movieCallback);
  97
  98         gEnv->pMovieSystem->SetCallback(&s_movieCallback);
  99         gEnv->pMovieSystem->AddMovieListener(nullptr, this);
 100         REGISTER_COMMAND("mov_goToFrameEditor", (ConsoleCommandFunc)GoToFrameCmd, 0, "Make a specified sequence go to a given frame time in the editor.");
 101 }
 102
 103 CAnimationContext::~CAnimationContext()
 104 {
 105         gEnv->pMovieSystem->SetCallback(NULL);
 106         gEnv->pMovieSystem->RemoveMovieListener(nullptr, this);
 107
 108         GetIEditor()->GetViewManager()->UnregisterCameraDelegate(&s_movieCallback);
 109         GetIEditor()->GetGameEngine()->RemoveListener(this);
 110         CTrackViewPlugin::GetSequenceManager()->RemoveListener(this);
 111         GetIEditor()->GetIUndoManager()->RemoveListener(this);
 112         GetIEditor()->UnregisterNotifyListener(this);
 113 }
 114
 115 void CAnimationContext::AddListener(IAnimationContextListener* pListener)
 116 {
 117         stl::push_back_unique(m_contextListeners, pListener);
 118 }
 119
 120 void CAnimationContext::RemoveListener(IAnimationContextListener* pListener)
 121 {
 122         stl::find_and_erase(m_contextListeners, pListener);
 123 }
 124
 125 void CAnimationContext::SetSequence(CTrackViewSequence* pSequence, bool bForce, bool bNoNotify)
 126 {
 127         CTrackViewSequence* pCurrentSequence = m_pSequence;
 128
 129         if (!bForce && pSequence == pCurrentSequence)
 130         {
 131                 return;
 132         }
 133
 134         // Prevent keys being created from time change
 135         const bool bRecording = m_bRecording;
 136         m_bRecording = false;
 137
 138         m_currTime = m_recordingCurrTime = SAnimTime(0.0f);
 139
 140         if (!m_bPostRenderRegistered)
 141         {
 142                 if (GetIEditor() && GetIEditor()->GetViewManager())
 143                 {
 144                         CViewport* pViewport = GetIEditor()->GetViewManager()->GetViewport(ET_ViewportCamera);
 145
 146                         if (pViewport)
 147                         {
 148                                 pViewport->AddPostRenderer(new CAnimationContextPostRender(this));
 149                                 m_bPostRenderRegistered = true;
 150                         }
 151                 }
 152         }
 153
 154         if (m_pSequence)
 155         {
 156                 m_pSequence->Deactivate();
 157
 158                 if (m_bPlaying)
 159                 {
 160                         m_pSequence->EndCutScene();
 161                 }
 162
 163                 m_pSequence->UnBindFromEditorObjects();
 164                 s_movieCallback.ResetCamera();
 165         }
 166
 167         m_pSequence = pSequence;
 168
 169         if (m_pSequence)
 170         {
 171                 if (m_bPlaying)
 172                 {
 173                         m_pSequence->BeginCutScene(true);
 174                 }
 175
 176                 UpdateTimeRange();
 177                 m_pSequence->Activate();
 178                 m_pSequence->PrecacheData(SAnimTime(0.0f));
 179
 180                 m_pSequence->BindToEditorObjects();
 181         }
 182
 183         ForceAnimation();
 184
 185         if (!bNoNotify)
 186         {
 187                 for (size_t i = 0; i < m_contextListeners.size(); ++i)
 188                 {
 189                         if (!pSequence)
 190                                 m_contextListeners[i]->OnTimeChanged(SAnimTime(0));
 191                         else
 192                                 m_contextListeners[i]->OnTimeChanged(pSequence->GetTimeRange().start);
 193
 194                         m_contextListeners[i]->OnSequenceChanged(m_pSequence);
 195                 }
 196         }
 197
 198         m_bRecording = bRecording;
 199 }
 200
 201 void CAnimationContext::UpdateTimeRange()
 202 {
 203         if (m_pSequence)
 204         {
 205                 m_timeRange = m_pSequence->GetTimeRange();
 206                 auto seqPlaybackRange = m_pSequence->GetPlaybackRange();
 207                 m_playbackRange.start = seqPlaybackRange.start != SAnimTime(-1) ? std::max(seqPlaybackRange.start, m_timeRange.start) : m_timeRange.start;
 208                 m_playbackRange.start = std::min(m_playbackRange.start, m_timeRange.end);
 209                 m_playbackRange.end = seqPlaybackRange.end != SAnimTime(-1) ? std::min(seqPlaybackRange.end, m_timeRange.end) : m_timeRange.end;
 210                 m_playbackRange.end = std::max(m_playbackRange.end, m_playbackRange.start);
 211                 m_playbackRange.end = std::max(m_playbackRange.end, m_timeRange.start);
 212         }
 213 }
 214
 215 void CAnimationContext::SetLoopMode(bool bLooping)
 216 {
 217         if (m_bLooping != bLooping)
 218         {
 219                 m_bLooping = bLooping;
 220
 221                 for (size_t i = 0; i < m_contextListeners.size(); ++i)
 222                         m_contextListeners[i]->OnLoopingStateChanged(m_bLooping);
 223         }
 224 }
 225
 226 void CAnimationContext::SetTime(SAnimTime t)
 227 {
 228         if (t < m_timeRange.start)
 229         {
 230                 t = m_timeRange.start;
 231         }
 232
 233         if (t > m_timeRange.end)
 234         {
 235                 t = m_timeRange.end;
 236         }
 237
 238         if (m_currTime == t)
 239         {
 240                 return;
 241         }
 242
 243         m_currTime = t;
 244         m_recordingCurrTime = t;
 245         ForceAnimation();
 246         UpdateAnimatedLights();
 247
 248         for (size_t i = 0; i < m_contextListeners.size(); ++i)
 249         {
 250                 m_contextListeners[i]->OnTimeChanged(m_currTime);
 251         }
 252 }
 253
 254 void CAnimationContext::SetRecording(bool bRecording)
 255 {
 256         if (bRecording == m_bRecording)
 257         {
 258                 return;
 259         }
 260
 261         m_bRecording = bRecording;
 262         m_bPlaying = false;
 263
 264         if (!bRecording && m_recordingTimeStep != SAnimTime(0.0f))
 265         {
 266                 SetAutoRecording(false, SAnimTime(0));
 267         }
 268
 269         // If started recording, assume we have modified the document.
 270         GetIEditor()->SetModifiedFlag();
 271
 272         for (size_t i = 0; i < m_contextListeners.size(); ++i)
 273         {
 274                 m_contextListeners[i]->OnRecordingStateChanged(bRecording);
 275         }
 276 }
 277
 278 void CAnimationContext::PlayPause(bool playOrPause)
 279 {
 280         if (m_bRecording)
 281         {
 282                 m_bWasRecording = true;
 283                 SetRecording(false);
 284         }
 285
 286         if (m_pSequence == nullptr || !m_bPlaying && !playOrPause || m_bPlaying && playOrPause == !m_bPaused)
 287         {
 288                 return;
 289         }
 290
 291         if (playOrPause)
 292         {
 293                 UpdateTimeRange();
 294                 // We need to deactivate/activate here to ensure all nodes update
 295                 // to the latest changes done in editor.
 296                 //
 297                 // TODO: Nicer would be a proper way just to refresh.
 298                 m_pSequence->Deactivate();
 299                 m_pSequence->Activate();
 300         }
 301
 302         if (!m_bPlaying && !m_bWasRecording)
 303         {
 304                 m_currTime = m_playbackRange.start;
 305         }
 306
 307         if (!m_bPlaying)
 308         {
 309                 m_bPlaying = true;
 310         }
 311
 312         if (!m_bPaused && !playOrPause)
 313         {
 314                 GetIEditor()->GetMovieSystem()->Pause();
 315
 316                 if (m_pSequence)
 317                 {
 318                         m_pSequence->Pause();
 319                 }
 320
 321                 m_bPaused = true;
 322         }
 323         else if (m_bPaused && playOrPause)
 324         {
 325                 GetIEditor()->GetMovieSystem()->Resume();
 326
 327                 if (m_pSequence)
 328                 {
 329                         m_pSequence->Resume();
 330                 }
 331
 332                 m_bPaused = false;
 333         }
 334
 335         for (size_t i = 0; i < m_contextListeners.size(); ++i)
 336         {
 337                 m_contextListeners[i]->OnPlaybackStateChanged(m_bPlaying, m_bPaused);
 338         }
 339
 340         if (m_bPaused && m_bWasRecording)
 341         {
 342                 m_bWasRecording = false;
 343                 SetRecording(true);
 344         }
 345 }
 346
 347 void CAnimationContext::Stop()
 348 {
 349         if (m_bWasRecording)
 350         {
 351                 m_bWasRecording = false;
 352                 SetRecording(true);
 353         }
 354
 355         m_bPlaying = false;
 356         m_bPaused = false;
 357         m_bSingleFrame = true; //still need one frame update
 358
 359         for (size_t i = 0; i < m_contextListeners.size(); ++i)
 360         {
 361                 m_contextListeners[i]->OnPlaybackStateChanged(m_bPlaying, m_bPaused);
 362         }
 363 }
 364
 365 void CAnimationContext::Update()
 366 {
 367         const SAnimTime lastTime = m_currTime;
 368         bool forceNotify = false;
 369
 370         if (m_bForceUpdateInNextFrame)
 371         {
 372                 ForceAnimation();
 373                 m_bForceUpdateInNextFrame = false;
 374         }
 375
 376         // If looking through camera object and recording animation, do not allow camera shake
 377         if ((GetIEditor()->GetViewManager()->GetCameraObjectId() != CryGUID::Null()) && IsRecording())
 378         {
 379                 GetIEditor()->GetMovieSystem()->EnableCameraShake(false);
 380         }
 381         else
 382         {
 383                 GetIEditor()->GetMovieSystem()->EnableCameraShake(true);
 384         }
 385
 386         if ((!m_bPlaying && !m_bAutoRecording && !m_bSingleFrame) || (m_bPlaying && m_bPaused && !m_bSingleFrame))
 387         {
 388                 if (m_pSequence)
 389                 {
 390                         m_pSequence->StillUpdate();
 391                 }
 392
 393                 if (!m_bRecording)
 394                 {
 395                         GetIEditor()->GetMovieSystem()->StillUpdate();
 396                 }
 397
 398                 return;
 399         }
 400
 401         if (!m_bPlaying || m_bPaused)
 402         {
 403                 return;
 404         }
 405
 406         ITimer* pTimer = GetIEditor()->GetSystem()->GetITimer();
 407         const float frameTime = pTimer->GetFrameTime();
 408
 409         if (m_bAutoRecording)
 410         {
 411                 m_recordingCurrTime += SAnimTime(frameTime * m_fTimeScale);
 412                 if ((m_recordingCurrTime - m_currTime) > m_recordingTimeStep)
 413                 {
 414                         m_currTime += m_recordingTimeStep;
 415                 }
 416
 417                 if (m_currTime > m_playbackRange.end)
 418                 {
 419                         SetAutoRecording(false, SAnimTime(0));
 420                 }
 421
 422                 // Send sync with physics event to all selected entities.
 423                 GetIEditor()->GetISelectionGroup()->SendEvent(EVENT_PHYSICS_GETSTATE);
 424         }
 425         else //normal playing code path
 426         {
 427                 bool updateTime = true;
 428
 429                 if (m_pSequence != NULL)
 430                 {
 431                         SAnimContext ac;
 432                         ac.dt = SAnimTime(0);
 433                         ac.time = m_currTime;
 434                         ac.bSingleFrame = m_bSingleFrame;
 435                         ac.m_activeCameraEntity = GetActiveCameraEntityId();
 436
 437                         if (m_bSingleFrame)
 438                         {
 439                                 m_bSingleFrame = false;
 440                                 forceNotify = true;
 441                                 updateTime = false;
 442                         }
 443
 444                         ac.bForcePlay = false;
 445                         m_pSequence->Animate(ac);
 446                         m_pSequence->SyncToConsole(ac);
 447                 }
 448
 449                 if (!m_bRecording)
 450                 {
 451                         GetIEditor()->GetMovieSystem()->PreUpdate(frameTime);
 452                         GetIEditor()->GetMovieSystem()->PostUpdate(frameTime);
 453                 }
 454
 455                 if (updateTime)
 456                 {
 457                         SAnimTime futureTime = m_currTime + SAnimTime(frameTime * m_fTimeScale);
 458                         if (futureTime > m_playbackRange.end)
 459                         {
 460                                 if (m_bLooping)
 461                                 {
 462                                         m_currTime = m_playbackRange.start + futureTime - m_playbackRange.end;
 463                                 }
 464                                 else
 465                                 {
 466                                         m_currTime = m_playbackRange.end;
 467                                         Stop();
 468                                 }
 469                         }
 470                         else
 471                         {
 472                                 m_currTime = futureTime;
 473                         }
 474                 }
 475         }
 476
 477         if (lastTime != m_currTime || forceNotify)
 478         {
 479                 for (size_t i = 0; i < m_contextListeners.size(); ++i)
 480                 {
 481                         m_contextListeners[i]->OnTimeChanged(m_currTime);
 482                 }
 483         }
 484
 485         UpdateAnimatedLights();
 486 }
 487
 488 void CAnimationContext::ForceAnimation()
 489 {
 490         // For force animation, disable auto recording
 491         const bool bAutoRecording = m_bAutoRecording;
 492
 493         if (bAutoRecording)
 494         {
 495                 SetAutoRecording(false, m_recordingTimeStep);
 496         }
 497
 498         if (m_pSequence)
 499         {
 500                 SAnimContext ac;
 501                 ac.time = m_currTime;
 502                 ac.bSingleFrame = true;
 503                 ac.bForcePlay = true;
 504                 ac.m_activeCameraEntity = GetActiveCameraEntityId();
 505
 506                 m_pSequence->Animate(ac);
 507                 m_pSequence->SyncToConsole(ac);
 508         }
 509
 510         if (bAutoRecording)
 511         {
 512                 SetAutoRecording(true, m_recordingTimeStep);
 513         }
 514
 515         GetIEditor()->UpdateViews();
 516 }
 517
 518 EntityId CAnimationContext::GetActiveCameraEntityId() const
 519 {
 520         if (GetIEditor() && GetIEditor()->GetViewManager())
 521         {
 522                 CViewManager* pViewManager = GetIEditor()->GetViewManager();
 523                 const CViewport* pViewport = pViewManager->GetActiveViewport();
 524                 if (pViewport && pViewport->IsSequenceCamera())
 525                 {
 526                         if (pViewManager->GetCameraObjectId() != s_movieCallback.GetActiveCameraObjectGUID())
 527                         {
 528                                 pViewManager->SetCameraObjectId(s_movieCallback.GetActiveCameraObjectGUID());
 529                         }
 530                 }
 531
 532                 const CBaseObject* pCameraObject = GetIEditor()->GetObjectManager()->FindObject(pViewManager->GetCameraObjectId());
 533                 const IEntity* pCameraEntity = pCameraObject ? ((CEntityObject*)pCameraObject)->GetIEntity() : nullptr;
 534                 if (pCameraEntity)
 535                 {
 536                         return pCameraEntity->GetId();
 537                 }
 538         }
 539
 540         return 0;
 541 }
 542
 543 void CAnimationContext::SetAutoRecording(bool bEnable, SAnimTime fTimeStep)
 544 {
 545         if (bEnable)
 546         {
 547                 m_bAutoRecording = true;
 548                 m_recordingTimeStep = fTimeStep;
 549
 550                 // Enables physics/ai.
 551                 GetIEditor()->GetGameEngine()->SetSimulationMode(true);
 552                 SetRecording(bEnable);
 553         }
 554         else
 555         {
 556                 m_bAutoRecording = false;
 557                 m_recordingTimeStep = SAnimTime(0);
 558
 559                 // Disables physics/ai.
 560                 GetIEditor()->GetGameEngine()->SetSimulationMode(false);
 561         }
 562 }
 563
 564 void CAnimationContext::GoToFrameCmd(IConsoleCmdArgs* pArgs)
 565 {
 566         if (pArgs->GetArgCount() < 3)
 567         {
 568                 gEnv->pLog->LogError("GoToFrame failed! You should provide two arguments of the 'sequence name' & 'frame time'.");
 569                 return;
 570         }
 571
 572         CAnimationContext* pAnimationContext = CTrackViewPlugin::GetAnimationContext();
 573
 574         assert(pAnimationContext);
 575         CTrackViewSequence* pSeq = pAnimationContext->GetSequence();
 576         string fullname = pSeq->GetName();
 577         assert(pSeq && strcmp(fullname.c_str(), pArgs->GetArg(1)) == 0);
 578         float targetFrame = (float)atof(pArgs->GetArg(2));
 579         assert(pSeq->GetTimeRange().start <= SAnimTime(targetFrame) && SAnimTime(targetFrame) <= pSeq->GetTimeRange().end);
 580         CTrackViewPlugin::GetAnimationContext()->m_currTime = SAnimTime(targetFrame);
 581         pAnimationContext->m_bSingleFrame = true;
 582
 583         pAnimationContext->ForceAnimation();
 584 }
 585
 586 void CAnimationContext::OnPostRender()
 587 {
 588         if (m_pSequence)
 589         {
 590                 SAnimContext ac;
 591                 ac.time = m_currTime;
 592                 ac.bSingleFrame = true;
 593                 ac.bForcePlay = true;
 594                 ac.m_activeCameraEntity = GetActiveCameraEntityId();
 595                 m_pSequence->Render(ac);
 596         }
 597 }
 598
 599 void CAnimationContext::UpdateAnimatedLights()
 600 {
 601         bool bLightAnimationSetActive = m_pSequence && (m_pSequence->GetFlags() & IAnimSequence::eSeqFlags_LightAnimationSet);
 602         if (bLightAnimationSetActive == false)
 603                 return;
 604
 605         std::vector<CBaseObject*> entityObjects;
 606         GetIEditor()->GetObjectManager()->FindObjectsOfType(RUNTIME_CLASS(CEntityObject), entityObjects);
 607         std::for_each(std::begin(entityObjects), std::end(entityObjects), [this](CBaseObject* pBaseObject)
 608         {
 609                 CEntityObject* pEntityObject = static_cast<CEntityObject*>(pBaseObject);
 610                 bool bLight = pEntityObject && (pEntityObject->GetEntityClass().Compare("Light") == 0);
 611                 if (bLight)
 612                 {
 613                   bool bTimeScrubbing = pEntityObject->GetEntityPropertyBool("bTimeScrubbingInTrackView");
 614                   if (bTimeScrubbing)
 615                   {
 616                     pEntityObject->SetEntityPropertyFloat("_fTimeScrubbed", m_currTime);
 617                   }
 618                 }
 619         });
 620 }
 621
 622 void CAnimationContext::BeginUndoTransaction()
 623 {
 624         m_bSavedRecordingState = m_bRecording;
 625 }
 626
 627 void CAnimationContext::EndUndoTransaction()
 628 {
 629         if (m_pSequence)
 630         {
 631                 m_pSequence->BindToEditorObjects();
 632         }
 633 }
 634
 635 void CAnimationContext::OnSequenceRemoved(CTrackViewSequence* pSequence)
 636 {
 637         if (m_pSequence == pSequence)
 638         {
 639                 SetSequence(nullptr, true, false);
 640         }
 641 }
 642 void CAnimationContext::OnEditorNotifyEvent(EEditorNotifyEvent event)
 643 {
 644         switch (event)
 645         {
 646         case eNotify_OnBeginGameMode:
 647                 if (m_pSequence)
 648                 {
 649                         m_pSequence->Resume();
 650                 }
 651
 652         case eNotify_OnBeginSceneSave:
 653         case eNotify_OnBeginLayerExport:
 654                 if (m_pSequence)
 655                 {
 656                         m_sequenceName = m_pSequence->GetName();
 657                 }
 658                 else
 659                 {
 660                         m_sequenceName = "";
 661                 }
 662
 663                 m_sequenceTime = GetTime();
 664
 665                 m_bSavedRecordingState = m_bRecording;
 666                 SetSequence(nullptr, true, true);
 667                 break;
 668
 669         case eNotify_OnEndGameMode:
 670         case eNotify_OnEndSceneSave:
 671         case eNotify_OnEndLayerExport:
 672                 m_currTime = m_sequenceTime;
 673                 SetSequence(CTrackViewPlugin::GetSequenceManager()->GetSequenceByName(m_sequenceName), true, true);
 674                 SetTime(m_sequenceTime);
 675                 break;
 676
 677         case eNotify_OnClearLevelContents:
 678                 SetSequence(nullptr, true, false);
 679                 break;
 680
 681         case eNotify_OnBeginNewScene:
 682                 SetSequence(nullptr, false, false);
 683                 break;
 684
 685         case eNotify_OnBeginLoad:
 686                 m_bSavedRecordingState = m_bRecording;
 687                 CTrackViewPlugin::GetAnimationContext()->SetSequence(nullptr, false, false);
 688                 break;
 689
 690         case eNotify_CameraChanged:
 691                 ForceAnimation();
 692                 break;
 693         }
 694 }
 695
 696 void CAnimationContext::OnMovieEvent(EMovieEvent movieEvent, IAnimSequence* pAnimSequence)
 697 {
 698         if (gEnv->IsEditorGameMode())
 699                 return;
 700
 701         switch (movieEvent)
 702         {
 703         case eMovieEvent_Started:
 704                 {
 705                         CTrackViewSequence* pTrackViewSequence = CTrackViewPlugin::GetSequenceManager()->GetSequenceByName(pAnimSequence->GetName());
 706                         SetSequence(pTrackViewSequence, true, false);
 707                 }
 708                 break;
 709         case eMovieEvent_Stopped:
 710                 SetSequence(nullptr, true, false);
 711                 break;
 712         default:
 713                 break;
 714         }
 715 }