Revision control
++ // Copyright (C) 2017 Klaralvdalens Datakonsult AB (KDAB).
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
++
++ #include "handler_p.h"
++ #include <Qt3DAnimation/private/managers_p.h>
++ #include <Qt3DAnimation/private/loadanimationclipjob_p.h>
++ #include <Qt3DAnimation/private/findrunningclipanimatorsjob_p.h>
++ #include <Qt3DAnimation/private/evaluateclipanimatorjob_p.h>
++ #include <Qt3DAnimation/private/buildblendtreesjob_p.h>
++ #include <Qt3DAnimation/private/evaluateblendclipanimatorjob_p.h>
++ #include <Qt3DAnimation/private/animationlogging_p.h>
++ #include <Qt3DAnimation/private/buildblendtreesjob_p.h>
++ #include <Qt3DAnimation/private/evaluateblendclipanimatorjob_p.h>
++ #include <Qt3DCore/private/qaspectjob_p.h>
++ #include <Qt3DCore/private/vector_helper_p.h>
++
++ QT_BEGIN_NAMESPACE
++
++ namespace Qt3DAnimation {
++ namespace Animation {
++
++ Handler::Handler()
++ : m_animationClipLoaderManager(new AnimationClipLoaderManager)
++ , m_clockManager(new ClockManager)
++ , m_clipAnimatorManager(new ClipAnimatorManager)
++ , m_blendedClipAnimatorManager(new BlendedClipAnimatorManager)
++ , m_channelMappingManager(new ChannelMappingManager)
++ , m_channelMapperManager(new ChannelMapperManager)
++ , m_clipBlendNodeManager(new ClipBlendNodeManager)
++ , m_skeletonManager(new SkeletonManager)
++ , m_loadAnimationClipJob(new LoadAnimationClipJob)
++ , m_findRunningClipAnimatorsJob(new FindRunningClipAnimatorsJob)
++ , m_buildBlendTreesJob(new BuildBlendTreesJob)
++ , m_simulationTime(0)
++ {
++ m_loadAnimationClipJob->setHandler(this);
++ m_findRunningClipAnimatorsJob->setHandler(this);
++ m_buildBlendTreesJob->setHandler(this);
++ }
++
++ Handler::~Handler()
++ {
++ }
++
++ void Handler::setDirty(DirtyFlag flag, Qt3DCore::QNodeId nodeId)
++ {
++ switch (flag) {
++ case AnimationClipDirty: {
++ QMutexLocker lock(&m_mutex);
++ const auto handle = m_animationClipLoaderManager->lookupHandle(nodeId);
++ if (!m_dirtyAnimationClips.contains(handle))
++ m_dirtyAnimationClips.push_back(handle);
++ break;
++ }
++
++ case ChannelMappingsDirty: {
++ break;
++ }
++
++ case ClipAnimatorDirty: {
++ QMutexLocker lock(&m_mutex);
++ const auto handle = m_clipAnimatorManager->lookupHandle(nodeId);
++ if (!m_dirtyClipAnimators.contains(handle))
++ m_dirtyClipAnimators.push_back(handle);
++ break;
++ }
++
++ case BlendedClipAnimatorDirty: {
++ QMutexLocker lock(&m_mutex);
++ const HBlendedClipAnimator handle = m_blendedClipAnimatorManager->lookupHandle(nodeId);
++ if (!m_dirtyBlendedAnimators.contains(handle))
++ m_dirtyBlendedAnimators.push_back(handle);
++ break;
++ }
++ }
++ }
++
++ // Called by the Jobs
++ void Handler::setClipAnimatorRunning(const HClipAnimator &handle, bool running)
++ {
++ QMutexLocker lock(&m_mutex);
++
++ // Add clip to running set if not already present
++ if (running && !m_runningClipAnimators.contains(handle)) {
++ m_runningClipAnimators.push_back(handle);
++ ClipAnimator *clipAnimator = m_clipAnimatorManager->data(handle);
++ if (clipAnimator)
++ clipAnimator->setStartTime(m_simulationTime);
++ }
++
++ // If being marked as not running, remove from set of running clips
++ if (!running) {
++ m_runningClipAnimators.removeAll(handle);
++ }
++ }
++
++ // Called by the Jobs
++ void Handler::setBlendedClipAnimatorRunning(const HBlendedClipAnimator &handle, bool running)
++ {
++ QMutexLocker lock(&m_mutex);
++
++ // Add clip to running set if not already present
++ if (running && !m_runningBlendedClipAnimators.contains(handle)) {
++ m_runningBlendedClipAnimators.push_back(handle);
++ BlendedClipAnimator *blendedClipAnimator = m_blendedClipAnimatorManager->data(handle);
++ if (blendedClipAnimator)
++ blendedClipAnimator->setStartTime(m_simulationTime);
++ }
++
++ // If being marked as not running, remove from set of running clips
++ if (!running) {
++ const auto it = std::find_if(m_runningBlendedClipAnimators.begin(),
++ m_runningBlendedClipAnimators.end(),
++ [handle](const HBlendedClipAnimator &h) { return h == handle; });
++ if (it != m_runningBlendedClipAnimators.end())
++ m_runningBlendedClipAnimators.erase(it);
++ }
++ }
++
++ // The vectors may get outdated when the application removes/deletes an
++ // animator component in the meantime. Recognize this. This should be
++ // relatively infrequent so in most cases the vectors will not change at all.
++ void Handler::cleanupHandleList(QVector<HAnimationClip> *clips)
++ {
++ for (auto it = clips->begin(); it != clips->end(); ) {
++ if (!m_animationClipLoaderManager->data(*it))
++ it = clips->erase(it);
++ else
++ ++it;
++ }
++ }
++
++ void Handler::cleanupHandleList(QVector<HClipAnimator> *animators)
++ {
++ for (auto it = animators->begin(); it != animators->end(); ) {
++ if (!m_clipAnimatorManager->data(*it))
++ it = animators->erase(it);
++ else
++ ++it;
++ }
++ }
++
++ void Handler::cleanupHandleList(QVector<HBlendedClipAnimator> *animators)
++ {
++ for (auto it = animators->begin(); it != animators->end(); ) {
++ if (!m_blendedClipAnimatorManager->data(*it))
++ it = animators->erase(it);
++ else
++ ++it;
++ }
++ }
++
++ std::vector<Qt3DCore::QAspectJobPtr> Handler::jobsToExecute(qint64 time)
++ {
++ // Store the simulation time so we can mark the start time of
++ // animators which will allow us to calculate the local time of
++ // animation clips.
++ m_simulationTime = time;
++
++ std::vector<Qt3DCore::QAspectJobPtr> jobs;
++
++ QMutexLocker lock(&m_mutex);
++
++ // If there are any dirty animation clips that need loading,
++ // queue up a job for them
++ const bool hasLoadAnimationClipJob = !m_dirtyAnimationClips.isEmpty();
++ if (hasLoadAnimationClipJob) {
++ qCDebug(HandlerLogic) << "Added LoadAnimationClipJob";
++ cleanupHandleList(&m_dirtyAnimationClips);
++ m_loadAnimationClipJob->addDirtyAnimationClips(m_dirtyAnimationClips);
++ jobs.push_back(m_loadAnimationClipJob);
++ m_dirtyAnimationClips.clear();
++ }
++
++ // If there are dirty clip animators, find the set that are able to
++ // run. I.e. are marked as running and have animation clips and
++ // channel mappings
++
++ const bool hasFindRunningClipAnimatorsJob = !m_dirtyClipAnimators.isEmpty();
++ if (hasFindRunningClipAnimatorsJob) {
++ qCDebug(HandlerLogic) << "Added FindRunningClipAnimatorsJob";
++ cleanupHandleList(&m_dirtyClipAnimators);
++ m_findRunningClipAnimatorsJob->setDirtyClipAnimators(m_dirtyClipAnimators);
++ // Only set the dependency once
++ if (Q_UNLIKELY(m_findRunningClipAnimatorsJob->dependencies().empty()))
++ m_findRunningClipAnimatorsJob->addDependency(m_loadAnimationClipJob);
++ jobs.push_back(m_findRunningClipAnimatorsJob);
++ if (hasLoadAnimationClipJob)
++ m_dirtyClipAnimators.clear();
++ }
++
++ // Rebuild blending trees if a blend tree is dirty
++ const bool hasBuildBlendTreesJob = !m_dirtyBlendedAnimators.isEmpty();
++ if (hasBuildBlendTreesJob) {
++ const QVector<HBlendedClipAnimator> dirtyBlendedAnimators = Qt3DCore::moveAndClear(m_dirtyBlendedAnimators);
++ m_buildBlendTreesJob->setBlendedClipAnimators(dirtyBlendedAnimators);
++ jobs.push_back(m_buildBlendTreesJob);
++ }
++
++ // TODO: Parallelise the animator evaluation and property building at a finer level
++
++ // If there are any running ClipAnimators, evaluate them for the current
++ // time and send property changes
++ cleanupHandleList(&m_runningClipAnimators);
++ if (!m_runningClipAnimators.isEmpty()) {
++ qCDebug(HandlerLogic) << "Added EvaluateClipAnimatorJobs";
++
++ // Ensure we have a job per clip animator
++ const qsizetype oldSize = m_evaluateClipAnimatorJobs.size();
++ const qsizetype newSize = m_runningClipAnimators.size();
++ if (oldSize < newSize) {
++ m_evaluateClipAnimatorJobs.resize(newSize);
++ for (qsizetype i = oldSize; i < newSize; ++i) {
++ m_evaluateClipAnimatorJobs[i] = QSharedPointer<EvaluateClipAnimatorJob>::create();
++ m_evaluateClipAnimatorJobs[i]->setHandler(this);
++ }
++ }
++
++ // Set each job up with an animator to process and set dependencies
++ for (qsizetype i = 0; i < newSize; ++i) {
++ m_evaluateClipAnimatorJobs[i]->setClipAnimator(m_runningClipAnimators[i]);
++ Qt3DCore::QAspectJobPrivate::get(m_evaluateClipAnimatorJobs[i].data())->clearDependencies();
++ if (hasLoadAnimationClipJob)
++ m_evaluateClipAnimatorJobs[i]->addDependency(m_loadAnimationClipJob);
++ if (hasFindRunningClipAnimatorsJob)
++ m_evaluateClipAnimatorJobs[i]->addDependency(m_findRunningClipAnimatorsJob);
++ jobs.push_back(m_evaluateClipAnimatorJobs[i]);
++ }
++ }
++
++ // BlendClipAnimator execution
++ cleanupHandleList(&m_runningBlendedClipAnimators);
++ if (!m_runningBlendedClipAnimators.isEmpty()) {
++ // Ensure we have a job per clip animator
++ const qsizetype oldSize = m_evaluateBlendClipAnimatorJobs.size();
++ const qsizetype newSize = m_runningBlendedClipAnimators.size();
++ if (oldSize < newSize) {
++ m_evaluateBlendClipAnimatorJobs.resize(newSize);
++ for (qsizetype i = oldSize; i < newSize; ++i) {
++ m_evaluateBlendClipAnimatorJobs[i] = QSharedPointer<EvaluateBlendClipAnimatorJob>::create();
++ m_evaluateBlendClipAnimatorJobs[i]->setHandler(this);
++ }
++ }
++
++ // Set each job up with an animator to process and set dependencies
++ for (qsizetype i = 0; i < newSize; ++i) {
++ m_evaluateBlendClipAnimatorJobs[i]->setBlendClipAnimator(m_runningBlendedClipAnimators[i]);
++ Qt3DCore::QAspectJobPrivate::get(m_evaluateBlendClipAnimatorJobs[i].data())->clearDependencies();
++ if (hasLoadAnimationClipJob)
++ m_evaluateBlendClipAnimatorJobs[i]->addDependency(m_loadAnimationClipJob);
++ if (hasBuildBlendTreesJob)
++ m_evaluateBlendClipAnimatorJobs[i]->addDependency(m_buildBlendTreesJob);
++ jobs.push_back(m_evaluateBlendClipAnimatorJobs[i]);
++ }
++ }
++
++ return jobs;
++ }
++
++ } // namespace Animation
++ } // namespace Qt3DAnimation
++
++ QT_END_NAMESPACE