GLTF_Animator.h

Go to the documentation of this file.

/*
 * Copyright (c) 2020
 *      Side Effects Software Inc.  All rights reserved.
 *
 * Redistribution and use of Houdini Development Kit samples in source and
 * binary forms, with or without modification, are permitted provided that the
 * following conditions are met:
 * 1. Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 * 2. The name of Side Effects Software may not be used to endorse or
 *    promote products derived from this software without specific prior
 *    written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY SIDE EFFECTS SOFTWARE `AS IS' AND ANY EXPRESS
 * OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN
 * NO EVENT SHALL SIDE EFFECTS SOFTWARE BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
 * OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 * EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#ifndef __GLTF_ANIMATOR_H__
#define __GLTF_ANIMATOR_H__

#include "GLTFZ_API.h"

#include <GLTF/GLTF_Types.h>
#include <GLTFZ/GLTF_ExportRoot.h>
#include <GLTFZ/GLTF_Refiner.h>
#include <GU/GU_DetailHandle.h>
#include <OBJ/OBJ_Node.h>
#include <SOP/SOP_Node.h>
#include <UT/UT_Array.h>
#include <UT/UT_Map.h>

namespace GLTF_NAMESPACE
{

// Helper class for exporting GLTF animations
class GLTFZ_API GLTF_Animator
{
public:
    /*
    struct AnimatorSettings
    {
        fpreal tstart, tend;
    };
    */
    // For when the settings struct is used in the near future
    // GLTF_Animator(AnimatorSettings &settings);

    ~GLTF_Animator() = default;
    GLTF_Animator(GLTF_BaseErrorManager* error_manager);

    void registerNode(OBJ_Node *node, GLTF_Handle index);

    void registerGeo(
            SOP_Node *sop,
            GU_ConstDetailHandle& cooked_gdh,
            const GLTF_Handle node_handle,
            const GLTF_RefinerHandle &refiner);

    void registerGeo(
            SOP_Node* sop,
            const GLTF_Handle node_handle,
            const GLTF_RefinerHandle& refiner);

    bool addKeyFrame(fpreal time);

    // Outputs stored information (OBJ and SOP animations) to the ExportRoot
    void outputToRoot(GLTF_ExportRoot &root);
    
    // Applies transform animations to the node
    // There must be one transform in xforms per time sample
    // Time samples are added beforehand with addKeyFrame()
    void animateNodeTransform(
            GLTF_ExportRoot &root,
            GLTF_Handle node_handle,
            const UT_Array<UT_Matrix4D> &xforms);

    void animateMorphTargetWeights(
            GLTF_ExportRoot &root,
            GLTF_Handle node_handle,
            GLTF_Handle weights_handle);

    void setAnimationName(const UT_StringHolder& anim_name);

private:
    template <typename T>
    struct ChannelInfo
    {
        bool using_global_key_times = false;
        UT_Array<fpreal32> key_times;
        UT_Array<T> values;
        bool time_dependent = false;
        GLTF_Interpolation interpolation = INTERP_NONE;
    };

    struct TransformAnimationInfo
    {
        GLTF_Handle node_handle = GLTF_INVALID_IDX;
        ChannelInfo<UT_Vector3F> translation;
        ChannelInfo<UT_QuaternionF> rotation;
        ChannelInfo<UT_Vector3F> scale;
    };

    struct GeoAnimationInfo
    {
        GLTF_Handle node_handle = GLTF_INVALID_IDX;
        GU_ConstDetailHandle cooked_gdh;
        GLTF_RefinerHandle refiner;
        bool added_first_frame = false;
        bool using_global_sample_times = true;
        UT_Array<fpreal32> sample_times;
    };

    // Returns true iff the transform is animated
    bool updateTransformInfo(OBJ_Node *node);
    bool updateTransformInfoFromMatrix(OBJ_Node *node);

    // Helper function to fill the info struct
    void addTRS(
            TransformAnimationInfo &info,
            UT_Vector3F &curr_t,
            UT_Vector3F &curr_euler,
            UT_Vector3F &curr_s,
            UT_Vector3F &prev_euler,
            exint count);

    // Determines if transform info can be extracted from parm channels instead
    // of xform matrices
    bool canUseTRS(OBJ_Node *node);

    template <int tuple_size, typename T>
    void updateChannels(
            ChannelInfo<T> &info,
            const PRM_Parm *parm,
            const int thread,
            bool is_rotation = false);

    // Helper functions for adding animation channels
    void addChannel(
            GLTF_ExportRoot &root,
            GLTF_AnimPath path,
            GLTF_Handle out_index,
            GLTF_Handle node_handle,
            GLTF_Interpolation interpolation,
            GLTF_Handle in_override = GLTF_INVALID_IDX);
    void addTransformChannels(
            GLTF_ExportRoot &root,
            const TransformAnimationInfo &info,
            GLTF_Handle times_index = GLTF_INVALID_IDX);

    UT_Map<OBJ_Node *, TransformAnimationInfo> myTransformMap;
    // To keep ordering consistent
    UT_Array<OBJ_Node *> myNodes;

    UT_Map<SOP_Node *, GeoAnimationInfo> myGeoMap;
    UT_Array<SOP_Node *> myGeos;

    // The input array for all animation samples
    UT_Array<fpreal32> myTimeSamples;

    GLTF_Handle myAnimation;
    GLTF_Handle myTimesAccessor;

    GLTF_BaseErrorManager* myErrorManager;

    UT_StringHolder myAnimationName;
};

} // namespace GLTF_NAMESPACE

#endif // __GLTF_ANIMATOR_H__