GLTF_CgltfUtils.h

Go to the documentation of this file.

#ifndef __GLTF_CgltfUtils_h__
#define __GLTF_CgltfUtils_h__

#include "GLTF_Channel.h"
#include "GLTF_SceneData.h"
#include "GLTF_Translator.h"

#include <GEO/GEO_StandardAttribs.h>
#include <SYS/SYS_Math.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_Vector3.h>

#include <cgltf.h>

class GLTF_AnimationData;
class GLTF_Reader;
class GLTF_Writer;
class OBJ_Node;
class UT_StringArray;

namespace GLTF_CgltfUtils
{
    struct AccessorMinMax
    {
        AccessorMinMax() = delete;
        AccessorMinMax(const UT_Vector3F& initial)
            : myMinBounds(initial)
            , myMaxBounds(initial)
        {

        }

        void checkAndUpdate(const UT_Vector3F& vec)
        {
            myMinBounds.x() = SYSmin(myMinBounds.x(), vec.x());
            myMinBounds.y() = SYSmin(myMinBounds.y(), vec.y());
            myMinBounds.z() = SYSmin(myMinBounds.z(), vec.z());
            myMaxBounds.x() = SYSmax(myMaxBounds.x(), vec.x());
            myMaxBounds.y() = SYSmax(myMaxBounds.y(), vec.y());
            myMaxBounds.z() = SYSmax(myMaxBounds.z(), vec.z());
        }

        UT_Vector3F myMinBounds;
        UT_Vector3F myMaxBounds;
    };

    UT_StringHolder         getHoudiniAttributeName(cgltf_attribute_type type);
    UT_StringHolder         getHoudiniAttributeName(const cgltf_attribute &attrib);

    UT_StringHolder         getGltfAttributeName(const GLTF_AttributeType type,
                                    const char* suffix = "");

    UT_StringHolder         getCgltfResultMessage(const cgltf_result& res);

    // Getters
    cgltf_primitive*        getPrimitive(
                                    const cgltf_data& data,
                                    const GLTF_Index mesh_id,
                                    const GLTF_Index prim_id);

    // Geometry helpers

    UT_StringHolder         getAnimationName(
                                    const cgltf_data& data,
                                    const cgltf_animation& anim);
    UT_StringHolder         getNodeName(
                                    const cgltf_data& data,
                                    const cgltf_node& node);
    UT_StringHolder         getMeshName(
                                    const cgltf_data& data,
                                    const cgltf_mesh& mesh);
    UT_StringHolder         getSceneName(
                                    const cgltf_data& data,
                                    const cgltf_scene& scene);
    UT_StringHolder         getSkinName(
                                    const cgltf_data& data,
                                    const cgltf_skin& skin);

    void                    getAnimationNames(
                                    const cgltf_data& data,
                                    UT_StringArray& names);

    UT_StringHolder         getCameraName(
                                    const cgltf_data& data,
                                    const cgltf_camera& camera);

    // Material helpers
    
    UT_StringHolder         getMaterialName(
                                    const cgltf_data& data,
                                    const cgltf_material& mat);

    bool                    hasDiffuseTexture(const cgltf_material& mat);
    bool                    hasMetallicRoughnessTexture(
                                    const cgltf_material& mat);
    bool                    hasNormalTexture(const cgltf_material& mat);
    bool                    hasOcclusionTexture(
                                    const cgltf_material& mat);
    bool                    hasEmissiveTexture(
                                    const cgltf_material& mat);
    bool                    hasSpecularColorTexture(
                                    const cgltf_material& mat);
    bool                    hasTransmissionTexture(
                                    const cgltf_material& mat);

    cgltf_image*            getTextureImage(const cgltf_texture_view& tv);
    GLTF_TextureTransform   getTextureTransform(const cgltf_texture_view& tv);

    // WARNING: this method will const_cast the cgltf_imge in order to call
    // cgltf_decode_uri on its URI, which modifies it in place.
    UT_StringHolder         getImageFilePath(
                                    const char* gltf_filepath,
                                    const cgltf_image& image);

    inline UT_Matrix4F      getMatrix4F(cgltf_float* gltf_mat)
    {
        return UT_Matrix4F(
                    gltf_mat[0], gltf_mat[1], gltf_mat[2], gltf_mat[3],
                    gltf_mat[4], gltf_mat[5], gltf_mat[6], gltf_mat[7],
                    gltf_mat[8], gltf_mat[9], gltf_mat[10], gltf_mat[11],
                    gltf_mat[12], gltf_mat[13], gltf_mat[14], gltf_mat[15]);
    }

    GLTFZ_API void          setNodeName(
                                    const GLTF_Index node_id,
                                    GLTF_Writer& writer,
                                    const char* name);

    void                    setNodeTransform(
                                    OBJ_Node* object,
                                    const GLTF_Index node_id,
                                    GLTF_Writer& writer,
                                    fpreal time);

    GLTFZ_API void          setMeshName(
                                    const GLTF_Index mesh_id,
                                    GLTF_Writer& writer,
                                    const char* name);

    GLTFZ_API UT_Matrix4F   getAnimatedTransformLocal(
                                    const GLTF_SceneData::Node& node,
                                    const float time,
                                    const GLTF_AnimationData& anim_data);

    GLTFZ_API UT_Matrix4F   getAnimatedTransformWorld(
                                    const GLTF_SceneData& scene,
                                    const GLTF_SceneData::Node& node,
                                    const float time,
                                    const GLTF_AnimationData& anim_data);

    GLTFZ_API GLTF_Index    findRootNode(
                                    const cgltf_data& data,
                                    const GLTF_Index node_id);

    UT_Matrix4F             getAnimatedTransformLocal(
                                    const GLTF_Translator::Node& node,
                                    const UT_Array<GLTF_Channel>& channels,
                                    float time);

    UT_StringHolder         buildNodePath(const cgltf_data& data,
                                    const cgltf_node& node);

    UT_StringArray          getUnsupportedImporterExtensions(
                                const GLTF_Reader& reader,
                                const cgltf_size extensions_count,
                                char** extensions);

    void                    addChildNodeToNode(
                                GLTF_Writer& writer,
                                cgltf_data& data,
                                GLTF_Index parent_id,
                                GLTF_Index child_id);

    bool                    isDefault(const cgltf_texture_view& tv);
    bool                    isDefault(const cgltf_pbr_metallic_roughness& pbr);
    bool                    isDefault(const cgltf_ior& ior);
    bool                    isDefault(const cgltf_specular& specular);
};

#endif // __GLTF_CgltfUtils_h__