GLTF_CgltfWrapper.h

Go to the documentation of this file.

#ifndef __GLTF_CgltfWrapper_h__
#define __GLTF_CgltfWrapper_h__

// cgltf_write.h includes cgltf.h, and because it's a header only library, the
// header guards will cause issues when trying to compile both the cgltf.h and
// cgltf_write.h implementation in GLTF_CgltfWrapper.C
#include <cgltf_write.h>

#include "GLTFZ_API.h"

#include "GLTF_Types.h"

#include <UT/UT_Assert.h>
#include <UT/UT_JSONParser.h>
#include <UT/UT_Options.h>
#include <UT/UT_UniquePtr.h>

#include <stdlib.h>
#include <string.h>

inline constexpr const char* cgltf_GltfVersion = "2.0";
inline constexpr const char* cgltf_GltfGenerator = "SideFX Houdini";

#define GLTF_DEFINE_APPEND_FUNC(                                               \
        func_name, cgltf_type, container, count_member)                        \
    cgltf_type& func_name()                                                    \
    {                                                                          \
        cgltf_type& new_elem = appendProperty(&container, count_member);       \
        initProperty(&new_elem);                                               \
        return new_elem;                                                       \
    }

template <typename T>
GLTF_Index
CGLTF_PTR_TO_INDEX(T* ptr)
{
    return reinterpret_cast<GLTF_Index>(ptr) - 1;
}

template <typename T>
T*
INDEX_TO_CGLTF_PTR(GLTF_Index id)
{
    return reinterpret_cast<T*>(id + 1);
}

class GLTFZ_API GLTF_CgltfWrapper
{
public:
    struct CgltfDataDeleter
    {
        void operator()(cgltf_data* data) const;
    };

public:
    GLTF_CgltfWrapper() {}
    ~GLTF_CgltfWrapper() {}

    void    setCgltfData(UT_UniquePtr<cgltf_data, CgltfDataDeleter>&& data)
    {
        myCgltfData = std::move(data);
    }

    cgltf_data*             getCgltfData() { return myCgltfData.get(); }
    const cgltf_data*       getCgltfData() const { return myCgltfData.get(); }

    cgltf_options&          getCgltfOptions() { return myCgltfOptions; }
    const cgltf_options&    getCgltfOptions() const { return myCgltfOptions; }

    bool                    fixupPointers();

private:
    inline static void gltf_free_func(void* user, void* ptr) { free(ptr); }

public:
    static void writeCharProperty(char** prop, const char* src)
    {
        *prop = (char*)malloc(sizeof(char) * (strlen(src) + 1));
        strcpy(*prop, src);
    }

    template <typename T>
    static void initProperty(T* prop)
    {
        memset(prop, 0, sizeof(*prop));
    }

    void initCgltfData(bool writing_mode = false)
    {
        initProperty(&myCgltfOptions);

        myCgltfData.reset(nullptr);
        cgltf_data* new_data = (cgltf_data*)malloc(sizeof(cgltf_data));
        initProperty(new_data);
        myCgltfData.reset(new_data);

        myCgltfData->memory.free_func = &gltf_free_func;

        if (writing_mode)
            initAsHoudiniAsset(myCgltfData->asset);
    }

    void initAsHoudiniAsset(cgltf_asset& asset)
    {
        asset.version
                = (char*)malloc(sizeof(char) * (strlen(cgltf_GltfVersion) + 1));
        strcpy(asset.version, cgltf_GltfVersion);
        asset.generator = (char*)malloc(
                sizeof(char) * (strlen(cgltf_GltfGenerator) + 1));
        strcpy(asset.generator, cgltf_GltfGenerator);
        asset.copyright = nullptr;
        asset.min_version = nullptr;
        asset.extensions = nullptr;
        initProperty(&asset.extras);
    }

    void initAttribute(
            cgltf_attribute& attrib,
            cgltf_size accessor_index,
            const char* name,
            cgltf_accessor* data_accessor = nullptr)
    {
        attrib.name = (char*)malloc(sizeof(char) * (strlen(name) + 1));
        strcpy(attrib.name, name);
        attrib.type = cgltf_attribute_type_invalid;
        attrib.index = accessor_index;
        attrib.data = data_accessor;
    }

    template <typename T>
    T& appendProperty(T** propList, cgltf_size& propSize)
    {
        if (*propList == nullptr && propSize == 0)
        {
            *propList = (T*)malloc(sizeof(T));
            propSize = 1;
            return (*propList)[0];
        }

        cgltf_size old_size = propSize;
        T* old_prop = *propList;

        propSize += 1;
        *propList = (T*)malloc(sizeof(T) * propSize);

        for (cgltf_size i = 0; i < old_size; ++i)
            (*propList)[i] = old_prop[i];

        free(old_prop);
        old_prop = nullptr;

        return (*propList)[propSize - 1];
    }

    template <typename T>
    T*& appendPropertyRef(T*** propList, cgltf_size& propSize)
    {
        if (*propList == nullptr && propSize == 0)
        {
            *propList = (T**)malloc(sizeof(T*));
            propSize = 1;
            return (*propList)[0];
        }

        cgltf_size old_size = propSize;
        T** old_prop = *propList;

        ++propSize;
        *propList = (T**)malloc(sizeof(T*) * propSize);

        for (cgltf_size i = 0; i < old_size; ++i)
            (*propList)[i] = old_prop[i];

        free(old_prop);
        old_prop = nullptr;

        return (*propList)[propSize - 1];
    }

    void setMainBuffer(cgltf_buffer& buf, uint8_t* data, cgltf_size size)
    {
        buf.size = size;
        myCgltfData->bin = data;
        myCgltfData->bin_size = size;
    }

    template <typename T>
    static bool propHasExtras(const T* prop)
    {
        return prop->extras.data != nullptr;
    }

    static UT_Options getExtrasAsOptions(const cgltf_extras& extras)
    {
        UT_AutoJSONParser parser(extras.data, strlen(extras.data) + 1);
        UT_Options options;
        options.load(parser, false, nullptr, false);
        return options;
    }

    // ---------------- Property Appenders ------------------
    // Below are provided macro-defined property appends as well as custom
    // property appenders. These are necessary because cgltf memory is manually
    // managed and we don't want anyone but this class to really be managing
    // that memory
    //

    GLTF_DEFINE_APPEND_FUNC(
            appendAccessor,
            cgltf_accessor,
            myCgltfData->accessors,
            myCgltfData->accessors_count);
    GLTF_DEFINE_APPEND_FUNC(
            appendAnimation,
            cgltf_animation,
            myCgltfData->animations,
            myCgltfData->animations_count);
    GLTF_DEFINE_APPEND_FUNC(
            appendBuffer,
            cgltf_buffer,
            myCgltfData->buffers,
            myCgltfData->buffers_count);
    GLTF_DEFINE_APPEND_FUNC(
            appendBufferView,
            cgltf_buffer_view,
            myCgltfData->buffer_views,
            myCgltfData->buffer_views_count);
    GLTF_DEFINE_APPEND_FUNC(
            appendCamera,
            cgltf_camera,
            myCgltfData->cameras,
            myCgltfData->cameras_count);
    GLTF_DEFINE_APPEND_FUNC(
            appendImage,
            cgltf_image,
            myCgltfData->images,
            myCgltfData->images_count);
    GLTF_DEFINE_APPEND_FUNC(
            appendLight,
            cgltf_light,
            myCgltfData->lights,
            myCgltfData->lights_count);
    GLTF_DEFINE_APPEND_FUNC(
            appendMaterial,
            cgltf_material,
            myCgltfData->materials,
            myCgltfData->materials_count);
    GLTF_DEFINE_APPEND_FUNC(
            appendMesh,
            cgltf_mesh,
            myCgltfData->meshes,
            myCgltfData->meshes_count);
    GLTF_DEFINE_APPEND_FUNC(
            appendNode,
            cgltf_node,
            myCgltfData->nodes,
            myCgltfData->nodes_count);
    GLTF_DEFINE_APPEND_FUNC(
            appendTexture,
            cgltf_texture,
            myCgltfData->textures,
            myCgltfData->textures_count);

    cgltf_scene& appendSceneAndSetToDefault()
    {
        cgltf_scene& new_scene = appendProperty(
                &myCgltfData->scenes, myCgltfData->scenes_count);
        initProperty(&new_scene);
        cgltf_size scene_id = myCgltfData->scenes_count - 1;
        myCgltfData->scene = reinterpret_cast<cgltf_scene*>(scene_id + 1);
        return new_scene;
    }

    cgltf_attribute& appendAttribute(
            cgltf_size mesh_id,
            cgltf_size prim_id,
            cgltf_size accessor_id,
            cgltf_attribute_type type,
            const char* name)
    {
        UT_ASSERT(mesh_id < myCgltfData->meshes_count);
        cgltf_mesh& mesh = myCgltfData->meshes[mesh_id];
        UT_ASSERT(prim_id < mesh.primitives_count);

        cgltf_attribute& new_attrib = appendProperty(
                &mesh.primitives[prim_id].attributes,
                mesh.primitives[prim_id].attributes_count);
        new_attrib.type = type;
        initAttribute(
                new_attrib, accessor_id, name,
                INDEX_TO_CGLTF_PTR<cgltf_accessor>(accessor_id));

        return new_attrib;
    }

    cgltf_attribute& appendDracoAttribute(
            cgltf_size mesh_id,
            cgltf_size prim_id,
            cgltf_size draco_id,
            cgltf_attribute_type type,
            const char* name)
    {
        UT_ASSERT(mesh_id < myCgltfData->meshes_count);
        cgltf_mesh& mesh = myCgltfData->meshes[mesh_id];
        UT_ASSERT(prim_id < mesh.primitives_count);

        cgltf_attribute& new_attrib = appendProperty(
                &mesh.primitives[prim_id].draco_mesh_compression.attributes,
                mesh.primitives[prim_id]
                        .draco_mesh_compression.attributes_count);
        new_attrib.type = type;
        initAttribute(
                new_attrib, draco_id, name,
                INDEX_TO_CGLTF_PTR<cgltf_accessor>(draco_id));

        return new_attrib;
    }

    cgltf_primitive& appendPrimitive(cgltf_size mesh_id)
    {
        UT_ASSERT(mesh_id < myCgltfData->meshes_count);
        cgltf_mesh& mesh = myCgltfData->meshes[mesh_id];
        cgltf_primitive& new_prim = appendProperty(
                &mesh.primitives, mesh.primitives_count);
        initProperty(&new_prim);
        new_prim.type = cgltf_primitive_type_triangles;
        return new_prim;
    }

    cgltf_animation_sampler& appendAnimationSampler(cgltf_animation& anim)
    {
        cgltf_animation_sampler& anim_sampler = appendProperty(
                &anim.samplers, anim.samplers_count);
        initProperty(&anim_sampler);
        return anim_sampler;
    }

    cgltf_animation_channel& appendAnimationChannel(cgltf_animation& anim)
    {
        cgltf_animation_channel& anim_channel = appendProperty(
                &anim.channels, anim.channels_count);
        initProperty(&anim_channel);
        return anim_channel;
    }

    // ---------------- Buffers ------------------
    //
    cgltf_result loadBufferFile(
                        cgltf_size buf_size,
                        const char* buf_uri,
                        const char* gltf_path,
                        void** data);

private:
    cgltf_options myCgltfOptions;
    UT_UniquePtr<cgltf_data, CgltfDataDeleter> myCgltfData;
};

#endif // __GLTF_CgltfWrapper_h__