AgentType.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/Skeleton.h>
#include <AtomsCore/JointChain.h>
#include <AtomsCore/Metadata/MapMetadata.h>
 
namespace Atoms
{
    class AgentType;
 
    typedef AtomsPtr<AgentType>  AgentTypePtr; 
 
    typedef AtomsPtr<const AgentType>  AgentTypeCPtr; 
 
 
    class ATOMS_EXPORT AgentType
    {
    public:
 
        enum RetargetMethodType
        {
            kPelvisToFeet = 0,
            kFootRootToFootIK,
            kBoundingBox,
            kUserValue
        };
 
        enum FacingDirection
        {
            kX = 0,
            kY,
            kZ,
            kNegativeX,
            kNegativeY,
            kNegativeZ
        };
 
        struct RetargetJointChainData
        {
            unsigned short thisIndex;                           // index of the chain in target
            unsigned short otherIndex;                          // index of the chain in source
            std::vector<unsigned short> thisMetadataIndices;    // joint indices in target for metadata transference
            std::vector<unsigned short> otherMetadataIndices;   // joint indices in source for metadata transference
            double factor;                                      // scaling factor for diff chain lengths
            AtomsCore::Vector3 offset;                          // offset in case of spines to respect bind pose
            AtomsCore::Matrix startRefDiffMatrix;               // matrix difference in bind-reference pose of start joint
            AtomsCore::Quaternion startRefDiff;                 // difference in bind-reference pose of start joint
            AtomsCore::Quaternion endRefDiff;                   // difference in bind-reference pose of end joint
            std::vector<AtomsCore::Quaternion> refDiffList;     // difference in bind-reference pose for each joint in chain order
        };
 
        AgentType();
 
 
        AgentType(unsigned int numJoints);
 
 
        AgentType(const AtomsCore::Skeleton& skeleton);
 
        ~AgentType();
 
 
        inline AtomsCore::Skeleton& skeleton();
 
 
        inline const AtomsCore::Skeleton& skeleton() const;
 
 
        void setSkeleton(const AtomsCore::Skeleton& skeleton);
 
 
        inline AtomsCore::MapMetadata& metadata();
 
 
        inline const AtomsCore::MapMetadata& metadata() const;
 
        inline const std::string& name() const;
 
        inline void setName(const std::string& name);
 
        void setRetargetingFactorMethod(const RetargetMethodType method = kPelvisToFeet, const double userFactor =1.0);
 
        const RetargetMethodType getRetargetingFactorMethod() const;
 
        const double getRetargetingUserFactor() const;
 
        const double evaluateRetargetingFactor(const RetargetMethodType method = kPelvisToFeet, const double userFactor = 1.0) const;
 
        const double getRetargetingFactor() const;
 
        size_t memSize();
 
        void hash(AtomsCore::MurmurHash3& h) const;
 
        void loadCharacterization();
 
        inline const std::vector<AtomsCore::JointChain>& jointChains() const;
 
        inline const std::vector<AtomsCore::Matrix>& retargetJointRefWorldMatrix() const;
 
        inline const std::vector<AtomsCore::Quaternion>& retargetJointOffset() const;
 
        void initializeRetargeting(const std::string &other);
 
        inline const std::vector<RetargetJointChainData>& retargetData(const std::string &other) const;
 
        inline const bool hasRetargetData(const std::string &other) const;
 
        double getPelvisHeight() const;
 
        inline double collisionRadius() const;
        
        inline void setCollisionRadius(double value);
 
 
        void setVirtualRoot(const bool value, const AtomsCore::Vector3& position);
 
        inline bool hasVirtualRoot() const;
 
        inline const AtomsCore::Vector3& virtualRootPosition() const;
 
        inline FacingDirection getFacingDirection() const;
 
        inline void setFacingDirection(FacingDirection direction);
 
    private:
 
        AtomsCore::Skeleton m_skeleton;
        
        AtomsCore::MapMetadata m_metadata;
 
        std::string m_name;
 
        FacingDirection m_facingDirection;
 
        std::vector<AtomsCore::JointChain> m_jointChains;
 
        std::map<std::string, std::vector<RetargetJointChainData>> m_retargetData;
 
        std::vector<AtomsCore::Matrix> m_retargetJointRefWorldMatrix;
 
        std::vector<AtomsCore::Quaternion> m_retargetJointOffset;
 
        AtomsCore::Vector3 m_virtualRootPosition;
 
        double m_radius;
 
        //| Retargeting factor
        double m_retargetingFactor;
 
        double m_retargetingUserFactor;
 
        RetargetMethodType m_retargetingMethod;
 
        bool m_hasVirtualRoot;
    };
}
 
namespace AtomsCore
{
    ATOMS_EXPORT AtomsCore::Archive& operator<<(AtomsCore::Archive& os, const Atoms::AgentType& agentType);
 
    ATOMS_EXPORT AtomsCore::Archive& operator >> (AtomsCore::Archive& is, Atoms::AgentType& agentType);
}
#include "AgentType.impl.h"