GLTF_AnimationData.h

Go to the documentation of this file.

#ifndef __GLTF_AnimationData_h__
#define __GLTF_AnimationData_h__

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

#include <UT/UT_Assert.h>
#include <UT/UT_Array.h>
#include <UT/UT_StringHolder.h>

class GLTFZ_API GLTF_Animation
{
public:

    void setId(const GLTF_Index id) { myId = id; }
    GLTF_Index getId() const { return myId; }

    void setName(const char* name)  { myName = name; }
    const UT_StringHolder& getName() const { return myName; }

    fpreal getStart() const { return myStartTime; }
    fpreal getEnd() const { return myEndTime; }

    void setTimeRange(const fpreal begin, const fpreal end)
    {
        myStartTime = begin;
        myEndTime = end;
    }

    void setNumChannels(int num)    { myChannels.entries(num); }
    exint getNumChannels() const    { return myChannels.entries(); }
    GLTF_Channel& getChannel(int i)
    {
        UT_ASSERT(i < myChannels.entries());
        return myChannels[i];
    }
    const GLTF_Channel& getChannel(int i) const
    {
        UT_ASSERT(i < myChannels.entries());
        return myChannels[i];
    }

    void addChannel(
        const GLTF_Index node_target,
        const GLTF_ChannelTarget anim_target,
        const GLTF_Interpolation interpolation,
        const UT_SharedPtr<GLTF_AnimChannelSource>& anim_source);

private:
    GLTF_Index              myId;
    UT_StringHolder         myName;
    UT_Array<GLTF_Channel>  myChannels;
    
    fpreal                  myStartTime;
    fpreal                  myEndTime;
};

class GLTFZ_API GLTF_AnimationData
{
public:
    bool                        hasAnimations() const
    {
        return myAnimations.entries() > 0;
    }

    void                        setNumAnimations(GLTF_Index count)
    {
        myAnimations.entries(count);
    }

    exint                       numAnimations() const
    {
        return myAnimations.entries();
    }

    GLTF_Animation&             getAnimation(GLTF_Index id)
    {
        UT_ASSERT(id < myAnimations.entries());
        return myAnimations[id];
    }
    const GLTF_Animation&       getAnimation(GLTF_Index id) const
    {
        UT_ASSERT(id < myAnimations.entries());
        return myAnimations[id];
    }

    void                        clear() { myAnimations.clear(); }

    bool                        isNodeAnimated(const GLTF_Index node_id) const;
    const GLTF_Channel*         findChannel(
                                        GLTF_ChannelTarget target,
                                        const GLTF_Index node_id) const;

private:

    UT_Array<GLTF_Animation>    myAnimations;
};

#endif