GLTF_ExportRoot.h

Go to the documentation of this file.

/*
 * Copyright (c) 2018
 *      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_EXPORTROOT_h__
#define __GLTF_EXPORTROOT_h__

#include "GLTFZ_API.h"

#include <GLTF/GLTF_Types.h>
#include <GLTFZ/GLTF_ImageExport.h>
#include <UT/UT_Array.h>
#include <UT/UT_ArraySet.h>
#include <UT/UT_WorkBuffer.h>

#include <GLTF/GLTF_Loader.h>

#include <vector>

constexpr const char *GENERATOR_STRING = "Houdini GLTF 2.0 Exporter";
constexpr const char *GLTF_VERSION = "2.0";

class UT_WorkBuffer;
class UT_JSONWriter;
class UT_OFStream;
class OP_Node;

namespace GLTF_NAMESPACE
{

class GLTFZ_API GLTF_ExportRoot
{
public:
    struct ExportSettings
    {
        bool exportNames = false;
    };

    struct InbetweenIndex
    {
        UT_StringHolder hero_channel;
        exint inbetween_idx;
    };

    GLTF_ExportRoot(ExportSettings s);
    ~GLTF_ExportRoot();

    bool HasCachedChannelImage(
        const UT_Array<GLTF_ChannelMapping> &mapping) const;
    GLTF_Handle
    GetCachedChannelImage(const UT_Array<GLTF_ChannelMapping> &mapping);
    void
    InsertCachedChannelImage(const UT_Array<GLTF_ChannelMapping> &mapping,
                             GLTF_Handle idx);

    UT_Map<UT_StringHolder, GLTF_Handle> &GetImageCache();
    UT_Map<const OP_Node *, GLTF_Handle> &GetMaterialCache();

    UT_Map<UT_StringHolder, UT_StringHolder>& GetMorphTargetToChannelMap();
    UT_Map<UT_StringHolder, exint>& GetMorphTargetChannels();
    UT_Map<UT_StringHolder, InbetweenIndex>& GetMorphTargetInbetweens();
    UT_Map<UT_StringHolder, UT_Array<fpreal32>>& GetMorphTargetInbetweenWeights();

    /// This keeps track of the amount of times a specific filename
    /// outputted to to avoid name collisions
    UT_Map<UT_StringHolder, GLTF_Int> &GetNameUsagesMap();

    ///
    /// Allocates additional space in the buffer in index bid.
    /// TODO:  stop allocating from reallocing space.
    ///
    void *BufferAlloc(GLTF_Handle bid, GLTF_Offset bytes, GLTF_Offset alignment,
                      GLTF_Offset &offset);

    ///
    /// Returns a reference to the internal root GLTF object
    ///
    GLTF_Loader &loader();

    ///
    /// Exports this structure as a GLTF file.
    ///
    bool ExportGLTF(const UT_String &path);

    ///
    /// Exports the file as GLB on os.  If a uri is defined on buffer 0,
    /// it will be ignored.  Otherwise, there are no modifications to the
    /// outputted JSON.
    ///
    bool ExportAsGLB(const UT_String &path);
    void SerializeJSON(UT_JSONWriter &writer);

    //
    // Convenience functions:  Will return the index of the created
    // node in the parameter idx.
    //
    GLTF_Accessor &CreateAccessor(GLTF_Handle &idx);
    GLTF_Animation &CreateAnimation(GLTF_Handle &idx);
    GLTF_Buffer &CreateBuffer(GLTF_Handle &idx);
    GLTF_BufferView &CreateBufferview(GLTF_Handle &idx);
    GLTF_Camera &CreateCamera(GLTF_Handle &idx);
    GLTF_Node &CreateNode(GLTF_Handle &idx);
    GLTF_Mesh &CreateMesh(GLTF_Handle &idx);
    GLTF_Scene &CreateScene(GLTF_Handle &idx);
    GLTF_Skin &CreateSkin(GLTF_Handle &idx);
    GLTF_Image &CreateImage(GLTF_Handle &idx);
    GLTF_Texture &CreateTexture(GLTF_Handle &idx);
    GLTF_Material &CreateMaterial(GLTF_Handle &idx);

    // Extension components
    GLTF_Light &createLight(GLTF_Handle &idx);

    GLTF_Accessor *getAccessor(GLTF_Handle idx);
    GLTF_Animation *getAnimation(GLTF_Handle idx);
    GLTF_Asset *getAsset();
    GLTF_Buffer *getBuffer(GLTF_Handle idx);
    GLTF_BufferView *getBufferView(GLTF_Handle idx);
    GLTF_Camera *getCamera(GLTF_Handle idx);
    GLTF_Image *getImage(GLTF_Handle idx);
    GLTF_Material *getMaterial(GLTF_Handle idx);
    GLTF_Mesh *getMesh(GLTF_Handle idx);
    GLTF_Node *getNode(GLTF_Handle idx);
    GLTF_Sampler *getSampler(GLTF_Handle idx);
    GLTF_Handle getDefaultScene();
    GLTF_Scene *getScene(GLTF_Handle idx);
    GLTF_Skin *getSkin(GLTF_Handle idx);
    GLTF_Texture *getTexture(GLTF_Handle idx);

    void SetDefaultScene(GLTF_Handle idx);

    const UT_Array<GLTF_Accessor *> &getAccessors() const;
    const UT_Array<GLTF_Animation *> &getAnimations() const;
    const UT_Array<GLTF_Buffer *> &getBuffers() const;
    const UT_Array<GLTF_BufferView *> &getBufferViews() const;
    const UT_Array<GLTF_Camera *> &getCameras() const;
    const UT_Array<GLTF_Extension *> &getExtensions() const;
    const UT_Array<GLTF_Image *> &getImages() const;
    const UT_Array<GLTF_Material *> &getMaterials() const;
    const UT_Array<GLTF_Mesh *> &getMeshes() const;
    const UT_Array<GLTF_Node *> &getNodes() const;
    const UT_Array<GLTF_Sampler *> &getSamplers() const;
    const UT_Array<GLTF_Scene *> &getScenes() const;
    const UT_Array<GLTF_Skin *> &getSkins() const;
    const UT_Array<GLTF_Texture *> &getTextures() const;

    template <typename T>
    inline GLTF_Handle addScalarArray(
        const UT_Array<T>& arr,
        GLTF_ComponentType type)
    {
        T min, max;
        GLTF_Handle bv_index = createScalarBufferView(arr, min, max);

        GLTF_Handle index;
        GLTF_Accessor &accessor = CreateAccessor(index);
        accessor.bufferView = bv_index;
        accessor.componentType = type;
        accessor.count = arr.entries();
        accessor.type = GLTF_TYPE_SCALAR;
        accessor.min.append(min);
        accessor.max.append(max);

        return index;
    }

    template <typename T>
    inline GLTF_Handle addScalarArraysInterleaved(
        const UT_Array<UT_Array<T>* >& arr,
        GLTF_ComponentType type)
    {
        T min, max;
        GLTF_Handle bv_index = createScalarBufferViewInterleaved(arr, min, max);

        GLTF_Handle index;
        GLTF_Accessor& accessor = CreateAccessor(index);
        accessor.bufferView = bv_index;
        accessor.componentType = type;
        accessor.count = arr.entries() * arr[0]->entries();
        accessor.type = GLTF_TYPE_SCALAR;
        accessor.min.append(min);
        accessor.max.append(max);

        return index;
    }

    template <typename T>
    inline GLTF_Handle createScalarBufferView(
        const UT_Array<T>& arr,
        T& min,
        T& max)
    {
        const exint count = arr.entries();
        GLTF_Offset size = count * sizeof(T);
        GLTF_Offset offset;
        void *buffer = BufferAlloc(0, size, sizeof(T), offset);

        memcpy(buffer, arr.getRawArray(), size);
        auto min_max = std::minmax_element(arr.begin(), arr.end());

        GLTF_Handle bv_index;
        GLTF_BufferView &bufferview = CreateBufferview(bv_index);
        bufferview.buffer = 0;
        bufferview.byteLength = size;
        bufferview.byteOffset = offset;

        min = *min_max.first;
        max = *min_max.second;
        return bv_index;
    }

    template <typename T>
    inline GLTF_Handle createScalarBufferViewInterleaved(
        const UT_Array<UT_Array<T>* >& arr,
        T& min,
        T& max)
    {
        const exint count = arr.entries() * arr[0]->entries();
        GLTF_Offset size = count * sizeof(T);
        GLTF_Offset offset;
        void* buffer = BufferAlloc(0, size, sizeof(T), offset);
        T* buf_t = static_cast<T*>(buffer);

        T local_min = (*arr[0])[0];
        T local_max = (*arr[0])[0];

        for (exint i = 0; i < arr[0]->entries(); ++i)
        {
            for (exint j = 0; j < arr.entries(); ++j)
            {
                buf_t[i * arr.entries() + j] = (*arr[j])[i];

                if ((*arr[j])[i] < local_min)
                    local_min = (*arr[j])[i];
                if ((*arr[j])[i] > local_max)
                    local_max = (*arr[j])[i];
            } 
        }

        GLTF_Handle bv_index;
        GLTF_BufferView& bufferview = CreateBufferview(bv_index);
        bufferview.buffer = 0;
        bufferview.byteLength = size;
        bufferview.byteOffset = offset;

        min = local_min;
        max = local_max;
        return bv_index;
    }

private:
    void
    OutputName(UT_JSONWriter &writer, const char *string, const char *value);

    void SerializeAsset(UT_JSONWriter &writer);
    void SerializeAnimations(UT_JSONWriter &writer);
    void SerializeAccessors(UT_JSONWriter &writer);
    void SerializeBuffers(UT_JSONWriter &writer);
    void SerializeBufferViews(UT_JSONWriter &writer);
    void SerializeCameras(UT_JSONWriter &writer);
    void SerializeExtensions(UT_JSONWriter &writer);
    void SerializeNodes(UT_JSONWriter &writer);
    void SerializeMeshes(UT_JSONWriter &writer);
    void SerializeMaterials(UT_JSONWriter &writer);
    void SerializePrimitives(UT_JSONWriter &writer,
                             const UT_Array<GLTF_Primitive> &primitive);
    void SerializeTextures(UT_JSONWriter &writer);
    void SerializeImages(UT_JSONWriter &writer);
    void SerializeScenes(UT_JSONWriter &writer);
    void SerializeSkins(UT_JSONWriter &writer);

    bool OutputBuffer(const char *folder, GLTF_Handle buffer) const;
    void OutputGLBBuffer(UT_OFStream &stream) const;

    // Pre-output pass:  these should be used only before outputting as they
    // may potentially invalidate handles
    void ResolveBufferLengths();
    void RemoveEmptyBuffers();

    // Any external files must be copied to the output folder as
    // GLTF is only required to support "http://" and relative URI
    void ConvertAbsolutePaths(const UT_String &base_path);

    // Returns true if opened output stream to given path.
    // Automatically creates directories in path.
    bool OpenFileStreamAtPath(const UT_String &path, UT_OFStream &os);

    UT_Array<UT_Array<char>> myBufferData;

    UT_Map<UT_StringHolder, GLTF_Handle> myNameUsagesMap;
    UT_Map<UT_StringHolder, GLTF_Handle> myImageMap;
    UT_Map<const OP_Node *, GLTF_Handle> myMaterialMap;

    UT_Map<UT_StringHolder, UT_StringHolder> myMorphTargetToChannelMap;
    UT_Map<UT_StringHolder, exint> myMorphTargetChannels;
    UT_Map<UT_StringHolder, InbetweenIndex> myMorphTargetInbetweens;
    UT_Map<UT_StringHolder, UT_Array<fpreal32>> myMorphTargetInbetweenWeights;

    std::map<std::vector<GLTF_ChannelMapping>, GLTF_Handle>
        myChannelImageMap;

    GLTF_Loader myLoader;
    ExportSettings mySettings;
};

} // namespace GLTF_NAMESPACE

#endif