AnimationClipLooper.impl.h

// ===========================================================================
// Copyright (c) 2015 Toolchefs Ltd. All rights reserved.
//
// Use of this software is subject to the terms of the Toolchefs license
// agreement provided at the time of installation or download, or which
// otherwise accompanies this software in either electronic or hard copy form.
// ===========================================================================
 
namespace Atoms
{
    /*
    void AnimationClipLooper::setAnimationClip(const AnimationClip &animationClip)
    {
        m_animationClip = &animationClip;
        
        m_numBlendFrames = 0;
        m_loopStart = 0;
        m_loopEnd = m_animationClip->numFrames();
    }
    */
 
    const AnimationClipCPtr AnimationClipLooper::animationClip() const
    {
        return m_animationClip;
    }
 
    bool AnimationClipLooper::isValid() const
    {
        return m_animationClip.get() != nullptr;
    }
 
    int AnimationClipLooper::numJoints() const
    {
        return m_animationClip->numJoints();
    }
 
    void AnimationClipLooper::setNumberBlendFrames(unsigned int value)
    {
        if (static_cast<int>(value) > (m_animationClip->numFrames() - 1) || (m_loopStart - value) < 0)
        {
            Logger::error() << "Blend frame value outside range " << m_loopStart << "-" << m_animationClip->numFrames() - 1;
            return;
        }
 
        m_numBlendFrames = value;
    }
 
    unsigned int AnimationClipLooper::numberBlendFrames() const
    {
        return m_numBlendFrames;
    }
 
    void AnimationClipLooper::setLoopStartFrame(unsigned int value)
    {
        if (value > m_loopEnd)
        {
            Logger::error() << "Loop start value outside range 0-" << m_loopEnd << " : " << value;
            return;
        }
 
        if (value - m_numBlendFrames < 0)
        {
            Logger::error() << "Blend frames value outside range " << value << "-" << m_animationClip->numFrames() - 1 << ". Resetting number of blend frames to 0.";
            m_numBlendFrames = 0;
        }
 
        m_loopStart = value;
    }
 
    unsigned int AnimationClipLooper::loopStartFrame() const
    {
        return m_loopStart;
    }
 
    void AnimationClipLooper::setLoopEndFrame(unsigned int value)
    {
        if (value < m_loopStart || static_cast<int>(value) > (m_animationClip->numFrames() - 1))
        {
            Logger::error() << "Loop end value outside range " << m_loopStart << "-" << m_animationClip->numFrames() - 1 << " : " << value;
            m_loopEnd = m_loopStart + m_animationClip->numFrames() - 1;
            return;
        }
        m_loopEnd = value;
    }
 
    unsigned int AnimationClipLooper::loopEndFrame() const
    {
        return m_loopEnd;
    }
    
    unsigned int AnimationClipLooper::mapTimeToFrame(const double time, double &reminder, unsigned int &nextFrame, int offset) const
    {
        if (!m_animationClip) return -1;
        unsigned int frame = m_animationClip->mapTimeToFrame(time, reminder);
        int relative_duration = std::max(1u, m_loopEnd - m_loopStart);
        int signedFrame = frame + offset;
        frame = signedFrame < 0 ? m_loopEnd - (std::abs(signedFrame) % relative_duration + m_loopStart): signedFrame;
        frame = frame % relative_duration + m_loopStart;
        nextFrame = frame == (relative_duration + m_loopStart) ? m_loopStart : frame + 1;
        return frame;
    }
 
    unsigned int AnimationClipLooper::mapFrameToFrame(const unsigned frame, unsigned int &nextFrame) const
    {
        if (!m_animationClip) return -1;
        int relative_duration = std::max(1u,m_loopEnd - m_loopStart);
        unsigned int resFrame = frame % relative_duration + m_loopStart;
        nextFrame = resFrame == (relative_duration + m_loopStart) ? m_loopStart : resFrame + 1;
        return resFrame;
    }
 
    inline unsigned int AnimationClipLooper::numFrames() const
    {
        return m_loopEnd - m_loopStart;
    }
    
    std::vector<std::string> AnimationClipLooper::metadataNames(const unsigned int jointId) const
    {
        if (!m_animationClip) return std::vector<std::string>();
        return (*m_animationClip)[static_cast<unsigned short>(jointId)].getArrayMetadataNames();
    }
 
    std::vector<std::string> AnimationClipLooper::staticMetadataNames(const unsigned int jointId) const
    {
        return (*m_animationClip)[static_cast<unsigned short>(jointId)].getStaticMetadataNames();
    }
 
    AtomsPtr<const AtomsCore::Metadata> AnimationClipLooper::getStaticMetadata(const unsigned int jointId, const std::string &metdataName) const
    {
        assert(m_animationClip != nullptr);
        assert(m_animationClip->numJoints() > jointId);
        return (*m_animationClip)[static_cast<unsigned short>(jointId)].getStaticMetadata(metdataName);
    }
 
    const AtomsCore::MapMetadata& AnimationClipLooper::staticMetadata(const unsigned int jointId) const
    {
        assert(m_animationClip != nullptr);
        assert(m_animationClip->numJoints() > jointId);
        const JointClipData& jClipData = (*m_animationClip)[static_cast<unsigned short>(jointId)];
        return jClipData.staticMetadata();
    }
 
    const std::map<std::string, AtomsPtr<AtomsCore::BaseTypedArrayMetadata>>& AnimationClipLooper::metadata(const unsigned int jointId) const
    {
        return (*m_animationClip)[static_cast<unsigned short>(jointId)].metadata();
    }
 
    const std::vector<std::string>& AnimationClipLooper::animatedMetadata(const unsigned int jointId) const
    {
        return (*m_animationClip)[static_cast<unsigned short>(jointId)].animatedMetadata();
    }
}