GLTF_SkeletalAnimation.h

Go to the documentation of this file.

#ifndef __GLTF_SkeletalAnimation_h__
#define __GLTF_SkeletalAnimation_h__

#include "GLTFZ_API.h"
#include "GLTF_Channel.h"
#include "GLTF_Translator.h"
#include "GLTF_Types.h"

#include <GA/GA_Handle.h>
#include <UT/UT_Array.h>
#include <UT/UT_Map.h>
#include <UT/UT_Set.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_Vector3.h>
#include <UT/UT_VectorTypes.h>

class GLTF_ErrorManager;
class GLTF_Reader;
class GU_Detail;
struct cgltf_node;

class GLTFZ_API GLTF_SkeletalAnimation
{
public:
    
    struct GLTF_Animation
    {
        GLTF_Index                  myAnimId;
        UT_StringHolder             myName;
        UT_Array<GLTF_Channel>      myChannels;
    };

public:

    /// Export API

    void                    reset();

    void                    setRestTime(fpreal time) { myRestTime = time; }
    fpreal                  getRestTime() const { return myRestTime; }

public:
    GLTF_SkeletalAnimation();

    bool                    loadSkeletalAnimation(
                                    GLTF_Reader& reader,
                                    GU_Detail* gdp,
                                    GLTF_Index anim_idx,
                                    GLTF_ErrorManager& errors);

    bool                    loadRestPose(
                                    GLTF_Reader& reader,
                                    GU_Detail* gdp,
                                    GLTF_Index skin_node_idx,
                                    GLTF_ErrorManager& errors);

    void                    getFrameRange(GLTF_Index anim_idx,
                                    fpreal& start,
                                    fpreal& end) const;

    void                    setSkeletonColor(const UT_Vector3R color)
    {
        mySkeletonColor = color;
    }
    void                    setImportSpace(GLTF_Translator::ImportSpace space)
    {
        myImportSpace = space;
    }

    void                    getActiveAnimationIds(UT_Array<GLTF_Index>& ids) const;
    UT_StringHolder         getActiveAnimationName(GLTF_Index id) const;

    bool                    updateSkeletalAnimation(GLTF_Reader& reader,
                                    GU_Detail* gdp,
                                    float time);

    bool                    isSceneAnimated(const GLTF_Reader& reader,
                                    const GLTF_Index scene_idx) const;
    bool                    isNodeAnimated(const GLTF_Reader& reader,
                                    const GLTF_Index node_idx) const;

private:

    // Finds the index of a cgltf_node object that is the root of the skeleton
    // (i.e. a common ancestor of all of the joints).
    bool            getSkeletonRoot(
                            GLTF_Reader &gltf_reader,
                            const GLTF_Index skin_idx,
                            GLTF_Index &root_node_idx,
                            GLTF_ErrorManager& errors);
    
    bool            updateAnimatedJointHierarchy(
                            GLTF_Reader& reader,
                            GU_Detail* gdp,
                            const GLTF_Index joint_idx,
                            const UT_Matrix4& parent_tm,
                            float time);

    bool            loadAnimation(
                            GLTF_Reader& reader,
                            GLTF_Animation& anim,
                            const GLTF_Index anim_idx,
                            GLTF_ErrorManager& errors);

    using GLTF_NodeChannelTarget            = std::pair<GLTF_Index, GLTF_ChannelTarget>;

    UT_Set<GLTF_NodeChannelTarget>          myNodeChannelPairs;

    // Skeletal Animation Class Members
    GLTF_Animation                          mySkeletalAnimation;
    UT_Array<GLTF_Index>                    myRootNodes;  // Index into the myJoints array
    UT_Map<GLTF_Index,
            GLTF_Translator::Node>          myJoints;
    UT_Vector3R                             mySkeletonColor{0.0, 0.09, 1.0};
    GLTF_Translator::ImportSpace            myImportSpace =
                                                GLTF_Translator::ImportSpace::World;

    fpreal                                  myRestTime = 1.0f;
};

#endif // __GLTF_SkeletalAnimation_h__