AnimationClip.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
{
    /***************************
     JointClipData
     ***************************/
    const std::string& JointClipData::name() const
    {
        return m_name;
    }
    
    void JointClipData::setName(const std::string& name)
    {
        m_name = name;
    }
    
    void JointClipData::setTranslation(const AtomsCore::Vector3 &translation, const unsigned int frame)
    {
        if (m_translation.size() > frame)
            m_translation[frame].setValue(translation);
    }
    
    void JointClipData::setRotation(const AtomsCore::Quaternion &rotation, const unsigned int frame)
    {
        if (m_rotation.size() > frame)
            m_rotation[frame] = rotation;
    }
    
    void JointClipData::setScale(const AtomsCore::Vector3 &scale, const unsigned int frame)
    {
        if (m_scale.size() > frame)
            m_scale[frame].setValue(scale);
    }
    
    const AtomsCore::Vector3& JointClipData::getTranslation(const unsigned int frame) const
    {
        return frame > m_numberOfFrames - 1 ? m_translation[m_numberOfFrames - 1] : m_translation[frame];
    }
 
    const AtomsCore::Quaternion& JointClipData::getRotation(const unsigned int frame) const
    {
        return frame > m_numberOfFrames - 1 ? m_rotation[m_numberOfFrames - 1] : m_rotation[frame];
    }
    
    const AtomsCore::Vector3& JointClipData::getScale(const unsigned int frame) const
    {
        return frame > m_numberOfFrames - 1 ? m_scale[m_numberOfFrames - 1] : m_scale[frame];
    }
    
    unsigned int JointClipData::getArrayMetadataType(const std::string &name) const
    {
        return m_metadata.at(name)->typeId();
    }
    
    template <class T> inline T JointClipData::getArrayMetadataValueAtFrame(const std::string &name, const unsigned int frame) const
    {
        auto metaIt = m_metadata.find(name);
        if (metaIt == m_metadata.end())
            return T();
 
        AtomsPtr<AtomsCore::TypedArrayMetadata<T>> vec = std::static_pointer_cast<AtomsCore::TypedArrayMetadata<T >>(metaIt->second);
        if (!vec)
            return T();
        return vec->getBasicTypeValue(frame > m_numberOfFrames - 1 ? m_numberOfFrames - 1 : frame);
    }
 
    template <class T>
    T JointClipData::getBlendedArrayMetadataValue(const std::string& name, const unsigned int initialFrame, const unsigned int finalFrame, const double weight) const
    {
        auto metaIt = m_metadata.find(name);
        if (metaIt == m_metadata.end())
            return T();
 
        if (initialFrame > m_numberOfFrames - 1)
        {
            //TODO - check this at
            return std::static_pointer_cast<AtomsCore::TypedArrayMetadata<T>>(metaIt->second)->getBasicTypeValue(m_numberOfFrames - 1);
        }
 
        if (weight < 0.0001)
        {
            return std::static_pointer_cast<AtomsCore::TypedArrayMetadata<T>>(metaIt->second)->getBasicTypeValue(initialFrame);
        }
 
        unsigned int fframe = finalFrame > m_numberOfFrames - 1 ? m_numberOfFrames - 1 : finalFrame;
        if (weight > 0.9999)
        {
            return std::static_pointer_cast<AtomsCore::TypedArrayMetadata<T>>(metaIt->second)->getBasicTypeValue(fframe);
        }
 
        return std::static_pointer_cast<AtomsCore::TypedArrayMetadata<T>>(metaIt->second)->getBlendedBasicTypeValue(initialFrame, fframe, weight);
    }
    
    AtomsPtr<AtomsCore::Metadata> JointClipData::getArrayMetadataAtFrame(const std::string &name, const unsigned int frame) const
    {
        auto metaIt = m_metadata.find(name);
        if (metaIt != m_metadata.cend())
        return metaIt->second->getBasicTypeMetadata(frame > m_numberOfFrames - 1 ? m_numberOfFrames - 1 : frame);
        return nullptr;
    }
    
    template <class T> void JointClipData::setArrayMetadataValue(const std::string &name, const unsigned int frame, T value)
    {
        AtomsPtr<AtomsCore::TypedArrayMetadata<T>> vec = std::static_pointer_cast<AtomsCore::TypedArrayMetadata<T>>( m_metadata[name] );
        vec->get()[frame] = value;
    }
    
    std::vector<std::string> JointClipData::getArrayMetadataNames() const
    {
        //return m_metadataNames;
        std::vector<std::string> metadataNames;
        metadataNames.reserve(m_metadata.size());
        for (auto it = m_metadata.cbegin(); it != m_metadata.cend(); it++)
            metadataNames.push_back(it->first);
        return metadataNames;
    }
 
    bool JointClipData::hasArrayMetadata(const std::string &name) const
    {
        return m_metadata.find(name) != m_metadata.cend();
    }
 
    void JointClipData::deleteArrayMetadata(const std::string& name)
    {
        auto it = m_metadata.find(name);
        if (it != m_metadata.end())
            m_metadata.erase(it);
    }
 
    template<typename T, typename V> inline void JointClipData::getArrayMetadataValues(const std::string& name, std::vector<V>& values)
    {
        if (m_metadata.find(name) == m_metadata.end())
            return;
        AtomsPtr<AtomsCore::TypedArrayMetadata<T>> vec = std::static_pointer_cast<AtomsCore::TypedArrayMetadata<T>>(m_metadata[name]);
        if (!vec)
            return;
        values = vec->get();
    }
    
    template<class T> void JointClipData::addArrayMetadata(const std::string &name, const bool force)
    {
        if (m_metadata.find(name) == m_metadata.end() || force)
        {
            AtomsPtr<AtomsCore::Metadata> data = (AtomsCore::MetadataFactory::instance().createMetadata(T::staticTypeStr()));
 
            AtomsPtr<T> d = std::static_pointer_cast<T>(data);
            d->get().resize(static_cast<unsigned int>(m_numberOfFrames)); 
            
            m_metadata[name] = d;
            
           // m_metadataNames.push_back(name);
        }
    }
 
    void JointClipData::addArrayMetadata(const std::string &name, AtomsPtr<AtomsCore::BaseTypedArrayMetadata>& data)
    {
        m_metadata[name] = data;
    }
 
    AtomsPtr<AtomsCore::BaseTypedArrayMetadata> JointClipData::getArrayMetadata(const std::string& name)
    {
        auto it = m_metadata.find(name);
        return (it != m_metadata.end()) ? it->second : AtomsPtr<AtomsCore::BaseTypedArrayMetadata>();
    }
 
    std::vector<std::string> JointClipData::getStaticMetadataNames() const
    {
        return m_staticMetadata.getKeys();
    }
 
    void JointClipData::setStaticMetadata(const std::string &name, AtomsCore::Metadata &metadata)
    {
        m_staticMetadata.addEntry(name, &metadata);
    }
 
    AtomsPtr<AtomsCore::Metadata> JointClipData::getStaticMetadata(const std::string &name)
    {
        return m_staticMetadata.getEntry(name);
    }
 
    AtomsPtr<const AtomsCore::Metadata> JointClipData::getStaticMetadata(const std::string &name) const
    {
        return m_staticMetadata.getEntry(name);
    }
 
    AtomsCore::MapMetadata& JointClipData::staticMetadata()
    {
        return m_staticMetadata;
    }
 
    const AtomsCore::MapMetadata& JointClipData::staticMetadata() const
    {
        return m_staticMetadata;
    }
 
    std::map<std::string, AtomsPtr<AtomsCore::BaseTypedArrayMetadata>>& JointClipData::metadata()
    {
        return m_metadata;
    }
 
    const std::map<std::string, AtomsPtr<AtomsCore::BaseTypedArrayMetadata>>& JointClipData::metadata() const
    {
        return m_metadata;
    }
 
    bool JointClipData::isTransformAnimated() const
    {
        return m_isTransformAnimated;
    }
 
    inline const std::vector<std::string>& JointClipData::animatedMetadata() const
    {
        return m_animatedMetadata;
    }
 
    /***************************
     AnimationClip
     ***************************/
    int AnimationClip::numJoints() const
    {
        return static_cast<int>(m_joints.size());
    }
    
    int AnimationClip::numFrames() const
    {
        return m_numberOfFrames;
    }
 
    double AnimationClip::fps() const
    {
        return m_fps;
    }
 
    void AnimationClip::setFps(double value)
    {
        m_fps = value;
    }
    
    unsigned int AnimationClip::mapTimeToFrame(const double time, double &reminder) const
    {
        double f = time * m_fps;
        unsigned int ret = static_cast<unsigned int>(f);
        reminder = f - ret;
        return ret;
    }
    
    void AnimationClip::setJointName(const unsigned int index, const std::string &jointName)
    {
        m_jointIndex[jointName] = index;
        m_joints[index].setName(jointName);
    }
 
    int AnimationClip::jointId(const std::string& jointName) const
    {
        auto it = m_jointIndex.find(jointName);
        return it != m_jointIndex.end() ? it->second : -1;
    }
    
    inline JointClipData& AnimationClip::operator[](unsigned short index)
    {
        return m_joints[index];
    }
    
    inline const JointClipData& AnimationClip::operator[](unsigned short index) const
    {
        return m_joints[index];
    }
    
    JointClipData& AnimationClip::at(unsigned short index)
    {
        return m_joints.at(index);
    }
    
    const JointClipData& AnimationClip::at(unsigned short index) const
    {
        return m_joints.at(index);
    }
    
    AtomsCore::MapMetadata& AnimationClip::metadata()
    {
        return m_metadata;
    }
    
    const AtomsCore::MapMetadata& AnimationClip::metadata() const
    {
        return m_metadata;
    }
 
    void AnimationClip::setDirection(const AtomsCore::Vector3& direction)
    {
        m_direction = direction;
    }
 
    AtomsCore::Vector3 AnimationClip::direction() const
    {
        return m_direction;
    }
 
    void AnimationClip::setDirectionType(unsigned int directionType)
    {
        m_directionType = directionType;
    }
 
    unsigned int AnimationClip::directionType() const
    {
        return m_directionType;
    }
 
    void AnimationClip::setDirectionFromJoints(unsigned int fromJoint, unsigned int toJoint)
    {
        m_directionFromJoints.first = fromJoint;
        m_directionFromJoints.second = toJoint;
    }
 
 
    const std::pair<unsigned int, unsigned int>& AnimationClip::directionFromJoints() const
    {
        return m_directionFromJoints;
    }
 
    void AnimationClip::disableFootLock(bool value)
    {
        m_isFootLockDisabled = value;
    }
 
    bool AnimationClip::isFootLockDisabled() const
    {
        return m_isFootLockDisabled;
    }
 
    const std::vector<int>& AnimationClip::transitionFrames() const
    {
        return m_transitionFrames;
    }
 
    unsigned int AnimationClip::additiveMode() const
    {
        return m_additiveMode;
    }
 
    const std::string & AnimationClip::additiveReferenceClip() const
    {
        return m_additiveReferenceClip;
    }
 
}