GLTF_Writer.h

Go to the documentation of this file.

#ifndef __GLTF_Writer_h__
#define __GLTF_Writer_h__

#include "GLTFZ_API.h"
#include "GLTF_AnimationData.h"
#include "GLTF_ErrorManager.h"
#include "GLTF_IO.h"
#include "GLTF_Types.h"

#include <OBJ/OBJ_Camera.h>
#include <UT/UT_Array.h>
#include <UT/UT_CameraParms.h>
#include <UT/UT_Map.h>
#include <UT/UT_Optional.h>
#include <UT/UT_StringHolder.h>
#include <UT/UT_StringMap.h>
#include <UT/UT_UniquePtr.h>
#include <UT/UT_WeakPtr.h>

#include <utility>
#include <variant>

class IMG_Format;
class OBJ_Light;

namespace draco
{
    class EncoderBuffer;
}

class GLTFZ_API GLTF_Writer
{
private:

    using GLTF_AttributeVariant = std::variant<
                UT_Array<int8_t>,
                UT_Array<uint8_t>,
                UT_Array<int16_t>,
                UT_Array<uint16_t>,
                UT_Array<uint32_t>,
                UT_Array<fpreal32>>;

    struct GLTF_DracoMeshCompressionInfo
    {
        GLTF_DracoMeshCompressionInfo();
        ~GLTF_DracoMeshCompressionInfo();

        UT_UniquePtr<draco::EncoderBuffer>  encoderBuffer;
        GLTF_Index                          indicesCount = 0;
        bool                                bufferViewExists = false;
        GLTF_Index                          bufferView;
    };

public:
                                            GLTF_Writer();
                                            ~GLTF_Writer();

        bool                                writeToFile(const char* filepath);

        void                                setResourceDirectory(
                                                const UT_StringHolder& dir)
        { myResourceDirectory = dir; }

        void                                setCopyright(
                                                const UT_StringHolder& copyright)
        { myCopyright = copyright; }

        bool                                initializeGltfData(
                                                const char* filename,
                                                const UT_WeakPtr<GLTF_AnimationData>& anim_data);

        const GLTF_ErrorManager&            getErrorManager() const
        {
            return myErrors;
        }

        GLTF_Index                          addNode();
        GLTF_Index                          addMesh();
        GLTF_Index                          addPrimitive(
                                                const GLTF_Index mesh_id,
                                                GLTF_PrimitiveType type);
        GLTF_Index                          addAttribute(
                                                const GLTF_Index mesh_id,
                                                const GLTF_Index prim_id,
                                                const GLTF_AttributeType type,
                                                const char* name);

        GLTF_Index                          addCamera(
                                                GLTF_CameraProjection proj,
                                                const UT_CameraParms& parms);

        GLTF_Index                          addLight(
                                                GLTFZ_LightType type);

        void                                addRootNodeToScene(
                                                GLTF_Index node_id,
                                                GLTF_Index scene_id);

        void                                setNodeMesh(
                                                GLTF_Index node_id,
                                                GLTF_Index mesh_id);

        GLTF_Index                          defaultScene() const;

        template<typename T>
        UT_Array<T>&                        createAttribute(
                                                const GLTF_AttributeInfo& info)
        {
            GLTF_AttributeVariant& attrib_variant = myAttributeData[info];
            attrib_variant = GLTF_AttributeVariant(std::in_place_type<UT_Array<T>>);
            return std::get<UT_Array<T>>(attrib_variant);
        }

        draco::EncoderBuffer*               getDracoEncoderBuffer(
                                                const GLTF_Index mesh_id,
                                                const GLTF_Index prim_id)
        {
            GLTF_MeshPrimId key(mesh_id, prim_id);
            return myDracoInfo[key].encoderBuffer.get();
        }

        void                                setDracoPrimIndexCount(
                                                const GLTF_Index mesh_id,
                                                const GLTF_Index prim_id,
                                                const GLTF_Index count)
        {
            GLTF_MeshPrimId key(mesh_id, prim_id);
            myDracoInfo[key].indicesCount = count;
        }

        UT_Array<uint32_t>&                 createVertexIndices(
                                                const GLTF_Index mesh_id,
                                                const GLTF_Index prim_id);

        void                                setPositionMinMax(
                                                const GLTF_AttributeInfo& info,
                                                const UT_Vector3F& min,
                                                const UT_Vector3F& max);

        bool                                containsMaterial(const char* node_path);
        GLTF_Index                          createOrGetMaterial(const char* node_path);

        bool                                containsImage(const char* name)
        {
            return myImageData.contains(name);
        }

        GLTF_Index                          createImage(const char* name);
        UT_Array<int8_t>&                   getImageBuffer(const char* name);
        GLTF_Index                          getImageIndex(const char* name);

        bool                                embedImageFile(
                                                const UT_StringHolder& filepath,
                                                const IMG_Format* format,
                                                const char* img_name);
        bool                                copyImageFileAndExport(
                                                const UT_StringHolder& filepath,
                                                const IMG_Format* format,
                                                const char* img_name);

        bool                                exportTextureWithImage(
                                                const UT_StringHolder& image_path,
                                                const UT_StringHolder& image_name,
                                                const IMG_Format* format,
                                                GLTF_ResourceExportLocation export_loc,
                                                GLTF_Index& tex_id);

        cgltf_data*                         getCgltfData()
        {
            return myIO.getCgltfData();
        }
        const cgltf_data*                   getCgltfData() const
        {
            return myIO.getCgltfData();
        }

        GLTF_CgltfWrapper*                  getCgltfWrapper()
        {
            return myIO.getCgltfWrapper();
        }

private:
        void                                flushDataToCgltf();
        void                                flushAnimData();
        void                                flushBuffer();

        void                                decomposeRestTransformMatricesForAnimatedNodes();

private:

        GLTF_IO                             myIO{GLTF_IO::Mode::Write};
        UT_WeakPtr<GLTF_AnimationData>      myAnimationData;
        GLTF_ErrorManager                   myErrors;

        UT_Array<uint8_t>                   myBuffer;
        
        UT_Map<
            GLTF_AttributeInfo,
            GLTF_AttributeVariant>        myAttributeData;

        using GLTF_MeshPrimId = std::pair<GLTF_Index, GLTF_Index>;

        UT_Map<
            GLTF_MeshPrimId,
            GLTF_DracoMeshCompressionInfo>  myDracoInfo;

        UT_Map<
            std::pair<
                GLTF_Index, GLTF_Index>,
            UT_Array<uint32_t>>             myVertexIndices;

        UT_Map<UT_StringHolder,
            GLTF_Index>                     myMaterials;

        UT_StringMap<
            std::pair<
                GLTF_Index,
                UT_Optional<
                    UT_Array<int8_t>>>>     myImageData;

        UT_StringHolder                     myResourceDirectory;

        UT_StringHolder                     myCopyright;
};

#endif