Skeleton.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 AtomsCore
{
    unsigned short Skeleton::numJoints() const
    {
        return m_numJoints;
    }
 
    Joint& Skeleton::operator[](unsigned short index)
    {
        return m_joints[index];
    }
 
    const Joint& Skeleton::operator[](unsigned short index) const
    {
        return m_joints[index];
    }
 
    JointCPtr Skeleton::root() const
    {
        return &m_joints[m_root];
    }
 
    JointPtr Skeleton::root()
    {
        return &m_joints[m_root];
    }
 
    void Skeleton::setRoot(unsigned short id)
    {
        if (id < m_numJoints)
            m_root = id;
    }
 
    unsigned short Skeleton::numFeet() const
    {
        return static_cast<unsigned short>(m_feet.size());
    }
 
    void Skeleton::clearFeet()
    {
        m_feet.clear();
    }
 
    void Skeleton::addFoot(unsigned short footIK, unsigned short footRoot, unsigned short footTip)
    {
        if ((footIK < m_numJoints) && (footRoot < m_numJoints) && (footTip < m_numJoints))
            m_feet.push_back(FootStruct(footIK, footRoot, footTip));
    }
 
    JointPtr Skeleton::footIK(unsigned short id)
    {
        return &m_joints[m_feet[id].footIK];
    }
 
    JointCPtr Skeleton::footIK(unsigned short id) const
    {
        return &m_joints[m_feet[id].footIK];
    }
 
    JointPtr Skeleton::footRoot(unsigned short id)
    {
        return &m_joints[m_feet[id].footRoot];
    }
 
    JointCPtr Skeleton::footRoot(unsigned short id) const
    {
        return &m_joints[m_feet[id].footRoot];
    }
 
    JointPtr Skeleton::footTip(unsigned short id)
    {
        return &m_joints[m_feet[id].footTip];
    }
 
    JointCPtr Skeleton::footTip(unsigned short id) const
    {
        return &m_joints[m_feet[id].footTip];
    }
 
    bool Skeleton::footHasPoleVector(unsigned short id) const
    {
        return m_feet[id].hasPoleVector;
    }
 
    AtomsCore::Vector3 Skeleton::footPoleVector(unsigned short id) const
    {
        return m_feet[id].poleVector;
    }
 
    void Skeleton::setFootPoleVector(unsigned short id, const AtomsCore::Vector3& value)
    {
        if (id < m_feet.size())
        {
            auto& foot = m_feet[id];
            foot.poleVector = value;
            foot.hasPoleVector = true;
        }
    }
 
    unsigned short Skeleton::footPelvis(unsigned short id) const 
    {
        return m_feet[id].pelvis;
    }
 
    const std::vector<unsigned short>& Skeleton::midJoints(unsigned short id) const
    {
        return m_feet[id].midJoints;
    }
 
    const std::vector<unsigned short>& Skeleton::legJoints(unsigned short id) const
    {
        return m_feet[id].legJoints;
    }
 
    unsigned short Skeleton::numPelvises() const
    {
        return static_cast<unsigned short>(std::max(m_pelvises.size(), static_cast<size_t>(1)));
    }
 
    void Skeleton::clearPelvises()
    {
        m_pelvises.clear();
    }
 
    void Skeleton::addPelvis(unsigned short pelvisJoint)
    {
        if (pelvisJoint < m_numJoints)
        {
            bool alreadyExists = false;
            for (auto& id : m_pelvises)
            {
                if (id == pelvisJoint)
                {
                    alreadyExists = true;
                    break;
                }
            }
            if (!alreadyExists)
            {
                m_pelvises.push_back(pelvisJoint);
 
                std::sort(m_pelvises.begin(), m_pelvises.end());
 
            }
        }
    }
 
    JointPtr Skeleton::pelvis(unsigned short id)
    {
        return m_pelvises.size() > 0 ?  &m_joints[m_pelvises[id]] : &m_joints[0];
    }
 
    JointCPtr Skeleton::pelvis(unsigned short id) const
    {
        return m_pelvises.size() > 0 ? &m_joints[m_pelvises[id]] : &m_joints[0];
    }
 
    unsigned int Skeleton::numPelvisChains(unsigned int id) const
    {
        if (m_pelvisChains.size() > id)
            return static_cast<unsigned int>(m_pelvisChains[id].size());
        else
            return 0;
    }
 
    int Skeleton::jointId(const std::string& name) const
    {
        std::unordered_map<std::string, int>::const_iterator it = m_jointNameIdMap.find(name);
        if (it != m_jointNameIdMap.end())
        {
            return it->second;
        }
        return -1;
    }
 
    void Skeleton::clear()
    {
        delete[] m_joints;
        m_joints = nullptr;
        m_feet.clear();
        m_jointNameIdMap.clear();
        m_jointMetadata.clear();
        m_pelvises.clear();
        m_root = 0;
        m_numJoints = 0;
    }
 
    MapMetadata& Skeleton::jointMetadata(unsigned short index)
    {
        return m_jointMetadata[index];
    }
 
    void Skeleton::setJointMetadata(unsigned short index, const MapMetadata& data)
    {
        m_jointMetadata[index] = data;
    }
 
    void Skeleton::addJointMetadata(unsigned short index, const std::string& key, AtomsPtr<Metadata> data)
    {
        m_jointMetadata[index].addEntry(key, data);
    }
 
    void Skeleton::addJointMetadata(unsigned short index, const std::string& key, Metadata *data)
    {
        m_jointMetadata[index].addEntry(key, data);
    }
 
    void Skeleton::clearJointsMetadata()
    {
        m_jointMetadata.clear();
    }
 
    const std::vector<unsigned short>& Skeleton::detachedJoints() const
    {
        return m_detachedJoints;
    }
 
    std::vector<SkeletonLod>& Skeleton::lods()
    {
        return m_lods;
    }
 
    const std::vector<SkeletonLod>& Skeleton::lods() const
    {
        return m_lods;
    }
}