Skeleton.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 <AtomsCore/Globals.h>
#include <AtomsCore/AtomsMath.h>
#include <AtomsCore/Joint.h>
#include <AtomsCore/Serialiser.h>
#include <AtomsCore/Metadata/Metadata.h>
#include <AtomsCore/Metadata/MapMetadata.h>
#include <string>
#include <unordered_map>
#include <vector>
#include <algorithm>
 
namespace AtomsCore
{
 
    struct SkeletonLod
    {
        std::vector<short> activeJoints;
        double screenSize;
        bool disableIk;
        bool disableFootLock;
    };
 
    struct FootStruct
    {
        FootStruct(unsigned short footIK, unsigned short footRoot, unsigned short footTip) :
                footIK(footIK), footTip(footTip), footRoot(footRoot), pelvis(0), numJoints(3), poleVector(0.0, 0.0, 0.0), hasPoleVector(false){};
 
        unsigned short footIK, footTip, footRoot, pelvis, numJoints;
        std::vector<unsigned short> midJoints;
        std::vector<unsigned short> legJoints;
        AtomsCore::Vector3 poleVector;
        bool hasPoleVector;
    };
 
    struct PelvisChain
    {
        unsigned int parent;
        unsigned int child;
        std::vector<unsigned int> chain;
    };
 
    class Skeleton;
 
    typedef Skeleton*  SkeletonPtr; 
 
    typedef const Skeleton*  SkeletonCPtr; 
 
 
    class ATOMSCORE_EXPORT Skeleton
    {
 
    public:
        typedef std::map<unsigned short, MapMetadata> JointMetadataMap;
 
        typedef std::vector<FootStruct> FeetVector;
 
 
        Skeleton(unsigned short numberOfJoints = 1);
 
        Skeleton(const Skeleton& rhs);
 
        ~Skeleton();
 
        Skeleton& operator=(const Skeleton& rhs);
 
 
        inline unsigned short numJoints() const;
 
 
        void setNumJoints(unsigned int numJoints);
 
 
        inline Joint& operator[](unsigned short index);
 
 
        inline const Joint& operator[](unsigned short index) const;
 
 
        Joint& joint(unsigned short index);
 
 
        const Joint& joint(unsigned short index) const;
 
 
        inline JointCPtr root() const;
 
 
        inline JointPtr root();
 
 
        inline void setRoot(unsigned short id);
 
 
        inline unsigned short numFeet() const;
 
        inline void clearFeet();
 
 
        inline void addFoot(unsigned short footIK, unsigned short footRoot, unsigned short footTip);
 
 
        inline JointPtr footIK(unsigned short id);
 
 
        inline JointCPtr footIK(unsigned short id) const;
 
 
        bool isFootIK(unsigned short id) const;
 
 
        inline JointPtr footRoot(unsigned short id);
 
 
        inline JointCPtr footRoot(unsigned short id) const;
 
 
        bool isFootRoot(unsigned short id) const;
 
 
        inline JointPtr footTip(unsigned short id);
 
 
        inline JointCPtr footTip(unsigned short id) const;
 
 
        bool isFootTip(unsigned short id) const;
 
        inline bool footHasPoleVector(unsigned short id) const;
 
        inline AtomsCore::Vector3 footPoleVector(unsigned short id) const;
 
        inline void setFootPoleVector(unsigned short id, const AtomsCore::Vector3& value);
 
 
        inline unsigned short footPelvis(unsigned short id) const;
 
 
         inline const std::vector<unsigned short>& midJoints(unsigned short id) const;
 
 
         inline const std::vector<unsigned short>& legJoints(unsigned short id) const;
 
 
        inline unsigned short numPelvises() const;
 
        inline void clearPelvises();
 
 
        inline void addPelvis(unsigned short pelvisJoint);
 
 
        inline JointPtr pelvis(unsigned short id);
 
 
        inline JointCPtr pelvis(unsigned short id) const;
 
 
        bool isPelvis(unsigned short id) const;
 
 
        inline unsigned int numPelvisChains(unsigned int id) const;
 
 
        PelvisChain* pelvisChain(unsigned int id, unsigned int chain);
 
 
        const PelvisChain* pelvisChain(unsigned int id, unsigned int chain) const;
 
 
        inline const std::vector<unsigned short>& detachedJoints() const;
 
 
        void buildIkData();
 
        void buildJointNameMap();
 
        void buildDetachedJointsList();
 
 
        inline int jointId(const std::string& name) const;
 
        inline void clear();
 
        size_t memSize() const;
 
        std::vector<unsigned short> jointMetadataIds() const;
 
 
        bool jointHasMetadata(unsigned short index);
 
 
        bool jointHasMetadata(unsigned short index) const;
 
 
        inline MapMetadata& jointMetadata(unsigned short index);
 
 
        const MapMetadata& jointMetadata(unsigned short index) const;
 
 
        inline void setJointMetadata(unsigned short index, const MapMetadata& data);
 
 
        inline void addJointMetadata(unsigned short index, const std::string& key, Metadata *data);
 
 
        inline void addJointMetadata(unsigned short index, const std::string& key, const AtomsPtr<Metadata> data);
 
 
        void clearJointMetadata(unsigned short index);
 
        inline void clearJointsMetadata();
 
        void hash(MurmurHash3& hash) const;
 
        inline std::vector<SkeletonLod>& lods();
 
        inline const std::vector<SkeletonLod>& lods() const;
 
        /*
        Replace . with _ inside the joint names
        */
        void sanitizeJointNames();
 
    private:
 
        JointPtr m_joints;
 
        FeetVector m_feet;
 
        std::unordered_map<std::string, int> m_jointNameIdMap;
 
        //TODO: This should be replaced with a MapMetadata when MapMetadata will support integers as keys
        JointMetadataMap m_jointMetadata;
 
        std::vector<unsigned short> m_pelvises;
 
        std::vector<std::vector<PelvisChain>> m_pelvisChains;
 
        std::vector<unsigned short> m_detachedJoints;
 
        std::vector<SkeletonLod> m_lods;
 
        unsigned short m_root;
 
        unsigned short m_numJoints;
 
    };
}
 
ATOMSCORE_EXPORT std::ostream& operator<<(std::ostream& os, const AtomsCore::Skeleton& skeleton);
 
namespace AtomsCore
{
    ATOMSCORE_EXPORT AtomsCore::Archive& operator<<(AtomsCore::Archive& os, const AtomsCore::Skeleton& skeleton);
 
    ATOMSCORE_EXPORT AtomsCore::Archive& operator >> (AtomsCore::Archive& is, AtomsCore::Skeleton& skeleton);
}
 
#include "Skeleton.impl.h"