SkeletonMapper.h

Go to the documentation of this file.

// Jolt Physics Library (https://github.com/jrouwe/JoltPhysics)
// SPDX-FileCopyrightText: 2022 Jorrit Rouwe
// SPDX-License-Identifier: MIT
 
#pragma once
 
#include <Jolt/Core/Reference.h>
#include <Jolt/Skeleton/Skeleton.h>
 
JPH_NAMESPACE_BEGIN
 
class SkeletonMapper : public RefTarget<SkeletonMapper>
{
public:
    class Mapping
    {
    public:
                            Mapping() = default;
                            Mapping(int inJointIdx1, int inJointIdx2, Mat44Arg inJoint1To2) : mJointIdx1(inJointIdx1), mJointIdx2(inJointIdx2), mJoint1To2(inJoint1To2), mJoint2To1(inJoint1To2.Inversed())
        {
            // Ensure bottom right element is 1 (numerical imprecision in the inverse can make this not so)
            mJoint2To1(3, 3) = 1.0f;
        }
 
        int                 mJointIdx1;                                                                 
        int                 mJointIdx2;                                                                 
        Mat44               mJoint1To2;                                                                 
        Mat44               mJoint2To1;                                                                 
    };
 
    class Chain
    {
    public:
                            Chain() = default;
                            Chain(Array<int> &&inJointIndices1, Array<int> &&inJointIndices2) : mJointIndices1(std::move(inJointIndices1)), mJointIndices2(std::move(inJointIndices2)) { }
 
        Array<int>          mJointIndices1;                                                             
        Array<int>          mJointIndices2;                                                             
    };
 
    class Unmapped
    {
    public:
                            Unmapped() = default;
                            Unmapped(int inJointIdx, int inParentJointIdx) : mJointIdx(inJointIdx), mParentJointIdx(inParentJointIdx) { }
 
        int                 mJointIdx;                                                                  
        int                 mParentJointIdx;                                                            
    };
 
    class Locked
    {
    public:
        int                 mJointIdx;                                                                  
        int                 mParentJointIdx;                                                            
        Vec3                mTranslation;                                                               
    };
 
    using CanMapJoint = function<bool (const Skeleton *, int, const Skeleton *, int)>;
 
    static bool             sDefaultCanMapJoint(const Skeleton *inSkeleton1, int inIndex1, const Skeleton *inSkeleton2, int inIndex2)
    {
        return inSkeleton1->GetJoint(inIndex1).mName == inSkeleton2->GetJoint(inIndex2).mName;
    }
 
    void                    Initialize(const Skeleton *inSkeleton1, const Mat44 *inNeutralPose1, const Skeleton *inSkeleton2, const Mat44 *inNeutralPose2, const CanMapJoint &inCanMapJoint = sDefaultCanMapJoint);
 
    void                    LockTranslations(const Skeleton *inSkeleton2, const bool *inLockedTranslations, const Mat44 *inNeutralPose2);
 
    void                    LockAllTranslations(const Skeleton *inSkeleton2, const Mat44 *inNeutralPose2);
 
    void                    Map(const Mat44 *inPose1ModelSpace, const Mat44 *inPose2LocalSpace, Mat44 *outPose2ModelSpace) const;
 
    void                    MapReverse(const Mat44 *inPose2ModelSpace, Mat44 *outPose1ModelSpace) const;
 
    int                     GetMappedJointIdx(int inJoint1Idx) const;
 
    bool                    IsJointTranslationLocked(int inJoint2Idx) const;
 
    using MappingVector = Array<Mapping>;
    using ChainVector = Array<Chain>;
    using UnmappedVector = Array<Unmapped>;
    using LockedVector = Array<Locked>;
 
    const MappingVector &   GetMappings() const                                                         { return mMappings; }
    MappingVector &         GetMappings()                                                               { return mMappings; }
    const ChainVector &     GetChains() const                                                           { return mChains; }
    ChainVector &           GetChains()                                                                 { return mChains; }
    const UnmappedVector &  GetUnmapped() const                                                         { return mUnmapped; }
    UnmappedVector &        GetUnmapped()                                                               { return mUnmapped; }
    const LockedVector &    GetLockedTranslations() const                                               { return mLockedTranslations; }
    LockedVector &          GetLockedTranslations()                                                     { return mLockedTranslations; }
 
private:
    MappingVector           mMappings;
    ChainVector             mChains;
    UnmappedVector          mUnmapped;                                                                  
    LockedVector            mLockedTranslations;
};
 
JPH_NAMESPACE_END