GLTF_Channel.h

Go to the documentation of this file.

#ifndef __GLTF_Channel_h__
#define __GLTF_Channel_h__

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

#include <CL/CL_SimpleChannel.h>
#include <UT/UT_Array.h>
#include <UT/UT_Quaternion.h>
#include <UT/UT_Set.h>
#include <UT/UT_SharedPtr.h>
#include <UT/UT_Vector3.h>

class OBJ_Node;

enum class GLTF_ChannelTarget
{
    Translation,
    Rotation,
    Scale,
    Weight
};

enum class GLTF_Interpolation
{
    Constant,
    Linear,
    Cubic
};

class GLTFZ_API GLTF_AnimChannelSource
{
public:

                                GLTF_AnimChannelSource() = default;
    virtual                     ~GLTF_AnimChannelSource() = default;
                                GLTF_AnimChannelSource(const GLTF_AnimChannelSource& other) = default;
    GLTF_AnimChannelSource&     operator=(const GLTF_AnimChannelSource& other) = default;
                                GLTF_AnimChannelSource(GLTF_AnimChannelSource&& other);

    virtual GLTF_AnimChannelSource*
                                clone() = 0;

    bool                        hasTarget(GLTF_ChannelTarget target);

    virtual bool                getTranslation(
                                        fpreal time,
                                        UT_Vector3F& trans) = 0;
    virtual bool                getRotation(
                                        fpreal time,
                                        UT_Quaternion& rot) = 0;
    virtual bool                getScale(
                                        fpreal time,
                                        UT_Vector3F& scale) = 0;
    virtual bool                getWeight(
                                        fpreal time,
                                        float& weight) = 0;

    virtual UT_XformOrder       getXformOrder(fpreal time) const = 0;

protected:

    UT_Set<GLTF_ChannelTarget>  myTargets;
};

class GLTFZ_API GLTF_ObjectSource : public GLTF_AnimChannelSource
{
public:
                                GLTF_ObjectSource();
                                ~GLTF_ObjectSource() override = default;
                                GLTF_ObjectSource(const GLTF_ObjectSource&) = default;
    GLTF_ObjectSource&          operator=(const GLTF_ObjectSource&) = default;
                                GLTF_ObjectSource(const GLTF_ObjectSource&&);

                                GLTF_ObjectSource(OBJ_Node* node);

    GLTF_AnimChannelSource*     clone() override;

    bool                        getTranslation(
                                    fpreal time,
                                    UT_Vector3F& trans) override;
    bool                        getRotation(
                                    fpreal time,
                                    UT_Quaternion& rot) override;
    bool                        getScale(
                                    fpreal time,
                                    UT_Vector3F& scale) override;
    bool                        getWeight(
                                    fpreal time,
                                    float& weight) override;

    UT_XformOrder               getXformOrder(fpreal time) const override;

private:

    OBJ_Node*                   myNode = nullptr;
};

struct GLTFZ_API GLTF_Channel
{
                                            GLTF_Channel() = default;
                                            ~GLTF_Channel() = default;

                                            GLTF_Channel(const GLTF_Channel&);
    GLTF_Channel&                           operator=(const GLTF_Channel&);

                                            GLTF_Channel(GLTF_Channel&&);

    void setChannelTarget(GLTF_ChannelTarget target);
    void setInterpolation(GLTF_Interpolation interp) { myInterpolation = interp; }
    void fillChannelComponents();

    GLTF_Index                              myNodeTarget;
    GLTF_ChannelTarget                      myChannelTarget;
    GLTF_Interpolation                      myInterpolation;

    UT_Array<float>                         myKeyframes;

    // This can be a Vec3 or a Vec4 depending on myChannelTarget
    UT_Array<float>                         myValues;
    
    UT_Array<CL_SimpleChannel>              myChannelComponents;

    UT_SharedPtr<GLTF_AnimChannelSource>    mySource;
};

#endif