AnimationSystem.cpp

Go to the documentation of this file.

 
 
#include "Headers/AnimationSystem.h"
 
#include "Geometry/Animations/Headers/SceneAnimator.h"
 
namespace Divide {
    AnimationSystem::AnimationSystem(ECS::ECSEngine& parentEngine, PlatformContext& context)
        : PlatformContextComponent(context),
          ECSSystem(parentEngine)
    {
    }
 
    void AnimationSystem::PreUpdate(const F32 dt)
    {
        PROFILE_SCOPE_AUTO( Profiler::Category::Scene );
 
        Parent::PreUpdate(dt);
 
        for (AnimationComponent* comp : _componentCache)
        {
            if (comp->animationIndex() == U32_MAX)
            {
                comp->playAnimation(0);
            }
 
            comp->_parentTimeStamp += comp->playAnimations() ? dt * comp->animationSpeed() : 0.0;
        }
    }
 
    void AnimationSystem::Update(const F32 dt)
    {
        PROFILE_SCOPE_AUTO( Profiler::Category::Scene );
 
        Parent::Update(dt);
 
        for (AnimationComponent* comp : _componentCache)
        {
            const SceneAnimator* animator = comp->animator();
 
            if (!animator || COMPARE(comp->_parentTimeStamp, comp->_currentTimeStamp))
            {
                return;
            }
 
            comp->_currentTimeStamp = comp->_parentTimeStamp;
            const D64 timeStampS = Time::MillisecondsToSeconds<D64>(comp->_currentTimeStamp);
 
            if (comp->playAnimations())
            {
                // Update Animations
                comp->_frameIndex = animator->frameIndexForTimeStamp(comp->animationIndex(), timeStampS);
 
                if (comp->animationIndex() != comp->previousAnimationIndex() && comp->animationIndex() != U32_MAX)
                {
                    comp->previousAnimationIndex(comp->animationIndex());
                }
            }
 
            // Resolve IK
            //if (comp->_resolveIK)
            //{
            //}
 
            // Resolve ragdoll
            // if (comp->_resolveRagdoll)
            //{
            //}
        }
    }
 
    void AnimationSystem::PostUpdate(const F32 dt)
    {
        Parent::PostUpdate(dt);
        for (AnimationComponent* const comp : _componentCache)
        {
            if (comp->frameTicked())
            {
                comp->parentSGN()->SendEvent(
                    ECS::CustomEvent
                    {
                        ._type = ECS::CustomEvent::Type::AnimationUpdated,
                        ._sourceCmp = comp
                    }
                );
            }
        }
    }
 
    bool AnimationSystem::saveCache(const SceneGraphNode* sgn, ByteBuffer& outputBuffer)
    {
        if (Parent::saveCache(sgn, outputBuffer))
        {
            const AnimationComponent* aComp = sgn->GetComponent<AnimationComponent>();
            if (aComp != nullptr && !aComp->saveCache(outputBuffer))
            {
                return false;
            }
 
            return true;
        }
 
        return false;
    }
 
    bool AnimationSystem::loadCache(SceneGraphNode* sgn, ByteBuffer& inputBuffer)
    {
        if (Parent::loadCache(sgn, inputBuffer))
        {
            AnimationComponent* aComp = sgn->GetComponent<AnimationComponent>();
            if (aComp != nullptr && !aComp->loadCache(inputBuffer))
            {
                return false;
            }
            return true;
        }
 
        return false;
    }
 
    void AnimationSystem::toggleAnimationState(const bool state) noexcept
    {
        AnimationComponent::GlobalAnimationState(state);
    }
 
    bool AnimationSystem::getAnimationState() const noexcept
    {
        return AnimationComponent::GlobalAnimationState();
    }
 
}//namespace Divide