AnimationClip.h

#pragma once
// ===========================================================================
// 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.
// ===========================================================================
 
#include <Atoms/Globals.h>
#include <AtomsCore/AtomsMath.h>
#include <Atoms/AgentType.h>
#include <AtomsCore/Metadata/MetadataFactory.h>
#include <AtomsCore/Metadata/TypedArrayMetadata.h>
#include <AtomsCore/Metadata/ArrayMetadata.h>
#include <AtomsCore/Metadata/MapMetadata.h>
#include <AtomsCore/Metadata/Vector2ArrayMetadata.h>
#include <AtomsCore/Metadata/Vector3ArrayMetadata.h>
#include <AtomsCore/Skeleton.h>
#include <vector>
#include <map>
 
#define DOUBLE_FOOT_DOWN_TRESHOLD 0.95
 
namespace Atoms
{
    class AnimationClip;
    class JointClipData;
    
    typedef AtomsPtr<AnimationClip>  AnimationClipPtr; 
    
    typedef AtomsPtr<const AnimationClip>  AnimationClipCPtr; 
 
 
    class ATOMS_EXPORT JointClipData
    {
 
    public:
 
 
        JointClipData(const unsigned int numberOfFrames);
 
        ~JointClipData();
        
 
        inline const std::string& name() const;
        //inline const char* name() const;
 
 
        inline void setName(const std::string& name);
 
 
        unsigned int getNumberOfFrames() { return m_numberOfFrames; };
 
        void setNumberOfFrames(const int value);
        
        inline void setTranslation(const AtomsCore::Vector3 &translation, const unsigned int frame);
 
        inline void setRotation(const AtomsCore::Quaternion &rotation, const unsigned int frame);
 
        inline void setScale(const AtomsCore::Vector3 &scale, const unsigned int frame);
        
        const inline AtomsCore::Vector3& getTranslation(const unsigned int frame) const;
 
        const inline AtomsCore::Quaternion& getRotation(const unsigned int frame) const;
 
        const inline AtomsCore::Vector3& getScale(const unsigned int frame) const;
 
        AtomsCore::Vector3 getBlendedTranslation(const unsigned int initialFrame, const unsigned int finalFrame, const double weight) const;
 
        AtomsCore::Quaternion getBlendedRotation(const unsigned int initialFrame, const unsigned int finalFrame, const double weight) const;
 
        AtomsCore::Vector3 getBlendedScale(const unsigned int initialFrame, const unsigned int finalFrame, const double weight) const;
 
        void getBlendedTranslationInPlace(AtomsCore::Vector3& out, const unsigned int initialFrame, const unsigned int finalFrame, const double weight) const;
 
        void getBlendedRotationInPlace(AtomsCore::Quaternion& out, const unsigned int initialFrame, const unsigned int finalFrame, const double weight) const;
 
        void getBlendedScaleInPlace(AtomsCore::Vector3& out, const unsigned int initialFrame, const unsigned int finalFrame, const double weight) const;
        
        inline unsigned int getArrayMetadataType(const std::string &name) const;
 
        template <class T> inline void setArrayMetadataValue(const std::string &name, const unsigned int frame, T value);
 
        inline AtomsPtr<AtomsCore::Metadata> getArrayMetadataAtFrame(const std::string &name, const unsigned int frame) const;
 
        template <class T> inline T getArrayMetadataValueAtFrame(const std::string &name, const unsigned int frame) const;
 
        AtomsPtr<AtomsCore::Metadata> getBlendedArrayMetadata(const std::string &name, const unsigned int initialFrame, const unsigned int finalFrame, const double weight) const;
 
        bool getBlendedArrayMetadataInPlace(const std::string& name, const unsigned int initialFrame, const unsigned int finalFrame, const double weight, AtomsPtr<AtomsCore::Metadata>& OutMeta) const;
 
        template <class T> inline T getBlendedArrayMetadataValue(const std::string &name, const unsigned int initialFrame, const unsigned int finalFrame, const double weight) const;
 
        AtomsPtr<AtomsCore::Metadata> getDoubleBlendedArrayMetadata(const std::string &name, const unsigned int initialFrame1, const unsigned int finalFrame1, const double weight1, const unsigned int initialFrame2, const unsigned int finalFrame2, const double weight2, const double finalWeight) const;
        bool getDoubleBlendedArrayMetadataInPlace(const std::string& name, const unsigned int initialFrame1, const unsigned int finalFrame1, const double weight1, const unsigned int initialFrame2, const unsigned int finalFrame2, const double weight2, const double finalWeight, AtomsPtr<AtomsCore::Metadata>& OutMeta) const;
 
        inline std::vector<std::string> getArrayMetadataNames() const;
 
        template<class T> inline void addArrayMetadata(const std::string &name, const bool force = false);
 
        template<typename T, typename V> inline void getArrayMetadataValues(const std::string& name, std::vector<V>& values);
 
        inline AtomsPtr<AtomsCore::BaseTypedArrayMetadata> getArrayMetadata(const std::string& name);
        
        inline void addArrayMetadata(const std::string &name, AtomsPtr<AtomsCore::BaseTypedArrayMetadata>& data);
 
        inline bool hasArrayMetadata(const std::string &name) const;
 
        inline void deleteArrayMetadata(const std::string& name);
 
        inline std::vector<std::string> getStaticMetadataNames() const;
 
        inline void setStaticMetadata(const std::string &name, AtomsCore::Metadata &metadata);
 
        inline AtomsPtr<AtomsCore::Metadata> getStaticMetadata(const std::string &name);
 
        inline AtomsPtr<const AtomsCore::Metadata> getStaticMetadata(const std::string &name) const;
 
        inline AtomsCore::MapMetadata& staticMetadata();
 
        inline const AtomsCore::MapMetadata& staticMetadata() const;
 
        inline std::map<std::string, AtomsPtr<AtomsCore::BaseTypedArrayMetadata>>& metadata();
 
        inline const std::map<std::string, AtomsPtr<AtomsCore::BaseTypedArrayMetadata>>& metadata() const;
 
        // Revers the animation
        void reverse();
 
        // Compute the transform animated tag and animated metadata
        void computeIsAnimated();
 
        // Return true if this joint data has animations
        inline bool isTransformAnimated() const;
        
        // Contains a list of all non static metadata
        inline const std::vector<std::string>& animatedMetadata() const;
 
        // Add the metadata to the animated metadata list
        void addAnimatedMetadata(const std::string& metadataName);
 
        void copyFrame(unsigned int from, unsigned int to);
 
    public:
 
        static bool getBindPoseData(
            const Atoms::JointClipData& jcd,
            int jointId,
            AtomsCore::Vector3& bindTranslate,
            AtomsCore::Vector3& bindScale,
            AtomsCore::Quaternion& bindRotate,
            AtomsCore::Quaternion& bindRotateOffset,
            const AtomsCore::Skeleton& skeleton
        );
 
        static bool getBindPoseData(
            const AtomsCore::MapMetadata& jcd,
            int jointId,
            AtomsCore::Vector3& bindTranslate,
            AtomsCore::Vector3& bindScale,
            AtomsCore::Quaternion& bindRotate,
            AtomsCore::Quaternion& bindRotateOffset,
            const AtomsCore::Skeleton& skeleton
        );
 
        
    private:
 
        std::vector<AtomsCore::Vector3> m_translation;
 
        std::vector<AtomsCore::Quaternion> m_rotation;
 
        std::vector<AtomsCore::Vector3> m_scale;
        
        std::map<std::string, AtomsPtr<AtomsCore::BaseTypedArrayMetadata>> m_metadata;
 
        std::vector<std::string> m_animatedMetadata;
 
        AtomsCore::MapMetadata m_staticMetadata;
        
        std::string m_name;
 
        unsigned int m_numberOfFrames;
 
        bool m_isTransformAnimated;
 
    };
    
    class ATOMS_EXPORT AnimationClip
    {
 
    public:
 
        enum DirectionType
        {
            kPelvis = 0,
            kStatic,
            kJoints,
            kClip,
            kLocal
        };
 
        enum AdditiveMode
        {
            kDisabled = 0,
            kBindPose,
            kReferenceClip
        };
 
        enum MirrorPlane
        {
            kX = 0,
            kY,
            kZ
        };
 
        enum MirrorSideJointsSearch
        {
            kAuto = 0,
            kByName
        };
 
        enum MirrorStringReplacementType
        {
            kAny = 0,
            kPrefix,
            kPostfix
        };
 
        AnimationClip();
        
        AnimationClip(const unsigned int numberOfJoints, const unsigned int numberOfFrames, const double fps);
        
        ~AnimationClip(){}
        
        inline int numJoints() const;
        
        inline int numFrames() const;
 
        void setNumFrames(const unsigned int numberOfFrames);
 
        void setNumJoints(const unsigned int numberOfJoints);
        
        inline double fps() const;
 
        inline void setFps(double value);
        
        inline unsigned int mapTimeToFrame(const double time, double &reminder) const;
        
        inline void setJointName(const unsigned int index, const std::string &jointName);
 
        inline int jointId(const std::string& jointName) const;
        
        inline JointClipData& operator[](unsigned short index);
        
        inline const JointClipData& operator[](unsigned short index) const;
        
        inline JointClipData& at(unsigned short index);
        
        inline const JointClipData& at(unsigned short index) const;
        
        inline AtomsCore::MapMetadata& metadata();
        
        inline const AtomsCore::MapMetadata& metadata() const;      
 
        inline void setDirection(const AtomsCore::Vector3& direction);
 
        inline AtomsCore::Vector3 direction() const;
 
        /* if directionType is kStatic then the clip use alway the direction saved by the setDireciton function,
        otherwise it takes the direction form the pelvis
        */
        inline void setDirectionType(unsigned int directionType);
 
        inline unsigned int directionType() const;
 
        inline void setDirectionFromJoints(unsigned int fromJoint, unsigned int toJoint);
 
        inline const std::pair<unsigned int, unsigned int>& directionFromJoints() const;
 
        inline void disableFootLock(bool value);
 
        inline bool isFootLockDisabled() const;
 
        inline const std::vector<int>& transitionFrames() const;
 
        void setTransitionFrames(const std::vector<int>& frames);
 
        void setCompatibleAgentType(const std::string &agentType);
 
        const std::string& getCompatibleAgentType() const;
 
        void setGlobalIKData(const std::string& jointName, const AtomsCore::Vector2ArrayMetadata& data);
 
        void setPerchingData(const AtomsCore::Vector2ArrayMetadata& data);
 
        void setSittingData(const AtomsCore::Vector2ArrayMetadata& data);
 
        void refreshSittingData();
 
        void setFootDownData(const std::string& jointName, const AtomsCore::Vector2ArrayMetadata& data);
 
        void addJointMetadata(const std::string& metadataName, const std::string& jointName, const int metadataType, const AtomsCore::Vector2ArrayMetadata& data);
 
        void setAdditiveMode(const unsigned int additiveMode);
 
        void setAdditiveReferenceClip(const std::string &clipName);
 
        inline unsigned int additiveMode() const;
 
        inline const std::string & additiveReferenceClip() const;
 
        void cacheFrameRootRotation(const std::string &agentType);
 
        void computeClipDirections(const std::string& agentType, std::vector<AtomsCore::Vector3> &directions) const;
 
        AtomsCore::Vector3 computeClipDirection(Atoms::AgentTypeCPtr atPtr, const int frame) const;
 
        /*
        \param height global y coordinated of the ground
        */
        void computePelvisAndFeetHeight(double height);
 
        void reverse();
 
        /*
        \param animMirrorPlane normal axis of the mirror plane in the animation
        \param bindMirrorPlane normal axis of the mirror plane in bind pose
        \param searchMode search mode to fin pair joints from left and right
        \param left string identifier of joints on the left
        \param right string identifier of joints on the right
        \param rawMirror when on the differences in bind pose on left and right joints is not used (DEPRECATED)
        \paremt stringReplacementType the strign replacement type: any, prefix or post
        */
        void computeMirror(
            const unsigned int animMirrorPlane,
            const unsigned int bindMirrorPlane,
            const unsigned int searchMode,
            const std::string &left,
            const std::string &right,
            const bool rawMirror = false,
            const unsigned int stringReplacementType = 0,
            const std::vector<std::string> skipJoints = {},
            const bool affectSkipJointsHierarchy = false);
 
        /*
        This function fills the transformAnimated and animatedMetadata members on each joint clip data
        */
        void computeAnimatedJoints();
 
        /*
        Replace . with _ inside the joint names
        */
        void sanitizeJointNames();
 
        /*
        Makes sure no joint in the clip has 0 scale on any of the axis by replacing any 0 value with small non-zero value
        */
        void sanitizeJointScales();
 
        double computeAverageVelocity() const;
 
        double computeAverageAngularVelocity() const;
 
        AtomsCore::Matrix clipJointWorldMatrix(
            const AtomsCore::Skeleton& skeleton,
            int clampedFrame, double weight,
            AtomsCore::JointCPtr pelvisJoint) const;
 
        /*
        This function converts the atoms_footOnGround metadata from a bool array to a double array metadata
        */
        void conformFootDownDataForLocomotion();
 
        /*
        This function transfers the motion from the skeleton root to the virtual root. Only works when the compatible agent type is set and virtual root is enabled.
        */
        void transferMotionToVirtualRoot();
 
        void setTransferMotionToVirtualRoot(const bool x, const bool y, const bool z, const bool overrideVirtualRootPos, const AtomsCore::Vector3& virtualRootPos);
 
        bool transferMotionToVirtualRootX() const { return m_transferMotionToVirtualRootX; };
 
        bool transferMotionToVirtualRootY() const { return m_transferMotionToVirtualRootY; };
 
        bool transferMotionToVirtualRootZ() const { return m_transferMotionToVirtualRootZ; };
 
        bool overrideVirtualRootPosition() const { return m_overrideVirtualRootPosition; };
 
        AtomsCore::Vector3 virtualRootPositionOverride() const { return m_virtualRootPositionOverride; };
 
        void refreshVirtualRoot();
 
 
    private:
 
        std::vector<JointClipData> m_joints;
 
        std::vector<AtomsCore::Vector2> m_sittingFramesData;
 
 
        std::vector<int> m_transitionFrames;
 
        std::map<std::string, unsigned int> m_jointIndex;
 
        AtomsCore::MapMetadata m_metadata;
        
        double m_fps;
 
        unsigned int m_numberOfFrames;
 
        AtomsCore::Vector3 m_direction;
 
        AtomsCore::Vector3 m_virtualRootPositionOverride;
 
        std::pair<unsigned int, unsigned int> m_directionFromJoints;
 
        unsigned int m_directionType;
 
        bool m_isFootLockDisabled;
 
        std::string m_compatibleAgentType;
 
        unsigned int m_additiveMode;
 
        std::string m_additiveReferenceClip;
 
        bool m_frameRootRotationCached;
 
        bool m_transferMotionToVirtualRootX;
 
        bool m_transferMotionToVirtualRootY;
 
        bool m_transferMotionToVirtualRootZ;
 
        bool m_overrideVirtualRootPosition;
 
        bool m_updateVirtualRootMotion;
    };
}
 
 
#include "AnimationClip.impl.h"