GLTF_Exporter.h

Go to the documentation of this file.

#ifndef __GLTF_Exporter_h__
#define __GLTF_Exporter_h__

#include "GLTFZ_API.h"
#include "GLTF_AnimationData.h"
#include "GLTF_ErrorManager.h"
#include "GLTF_ExportOptions.h"
#include "GLTF_Types.h"
#include "GLTF_Writer.h"

#include <GA/GA_ElementGroup.h>
#include <GA/GA_Types.h>
#include <UT/UT_Array.h>
#include <UT/UT_ArrayStringMap.h>
#include <UT/UT_Optional.h>
#include <UT/UT_SharedPtr.h>
#include <UT/UT_StringHolder.h>

class GLTF_Codec;
class GEO_PrimCamera;
class GU_Detail;
class GU_PrimPacked;
class OBJ_Camera;
class OBJ_Light;
class OBJ_Node;
class OP_Operator;
class SOP_Node;
class UT_InfoTree;

class GLTFZ_API GLTF_Exporter
{
public:

    GLTF_Writer&        getWriter() { return myWriter; }
    GLTF_ExportOptions& getExportOptions() { return myOptions; }
    const GLTF_ErrorManager& getErrorManager() { return myErrors; }

    void                setGltfFile(const char* filepath)
    {
        myExportFilePath = filepath;
    }

    void                setExportingTime(const fpreal time)
    {
        myExportingTime = time;
    }

    bool                exportObjectGraph(
                            UT_Array<OBJ_Node*>& root_obj_nodes);

    bool                exportSop(
                            SOP_Node& sop);

    bool                exportDetail(
                            const GU_Detail& gdp);

    bool                exportFrameAnimData(
                            const GLTF_Index anim_id,
                            const fpreal time,
                            const fpreal keyframe);

private:

    bool                doExportObjectGraph(
                            OBJ_Node& obj_node,
                            UT_Optional<GLTF_Index> parent_id);

    bool                doExportObjectCamera(
                            OBJ_Camera& camera,
                            const GLTF_Index* parent_id,
                            GLTF_Index* new_node_id,
                            const char* new_node_name);

    bool                doExportObjectLight(
                            OBJ_Light& light,
                            const GLTF_Index* parent_id,
                            GLTF_Index* new_node_id,
                            const char* new_node_name);

    bool                doExportSop(
                            SOP_Node& sop);

    bool                doExportDetail(
                            const GU_Detail& gdp,
                            const char* detail_name=nullptr);

    bool                doExportNode(
                            const GU_Detail& gdp,
                            const GLTF_Index* parent_id,
                            GLTF_Index* node_id,
                            const char* node_name);

    bool                doExportPackedPrimitive(
                            const GU_Detail& gdp,
                            const GU_PrimPacked& prim,
                            const GLTF_Index* parent_id,
                            GLTF_Index* exported_node);

    bool                doExportSopCamera(
                            const GEO_PrimCamera& prim_cam,
                            const GLTF_Index node_id,
                            const char* node_name);

    bool                doExportMesh(
                            const GU_Detail& src_gdp,
                            GLTF_Index &mesh_id);

    bool                doExportMeshPrimitives(
                            const GU_Detail& gdp,
                            GLTF_Index mesh_id);

    bool                doExportAssignedMaterial(
                            const GU_Detail& gdp,
                            const GLTF_Index mesh_id,
                            const GLTF_Index prim_id);

private:

    bool                exportGltfExtrasDictAttrib(
                            const GU_Detail& gdp,
                            const UT_StringHolder& attrib_name,
                            GA_AttributeOwner owner,
                            GLTF_Index prop_index,
                            GA_Offset attrib_offset = GA_DETAIL_OFFSET);

    bool                traverseAndExportPathAttribDefinedSceneGraph(
                            const UT_InfoTree& graph,
                            const UT_StringHolder& node_path,
                            const GLTF_Index* parent_id,
                            const UT_ArrayStringMap<int>& nodes_map,
                            UT_Array<GA_PrimitiveGroup>& prim_groups,
                            const GU_Detail& gdp);

    void                compensateForParentTransforms(
                            const GLTF_Index node_id,
                            const GLTF_Index* parent_node_id=nullptr);

private:

    UT_SharedPtr<GLTF_Codec>
                        createMatchingMeshCodec();
    UT_SharedPtr<GLTF_Codec>
                        createMatchingMaterialCodec(
                            const char* matname,
                            const OP_Operator* mat_op);

private:

    UT_StringHolder     myExportFilePath;

    GLTF_Writer         myWriter;
    GLTF_ExportOptions  myOptions;
    GLTF_ErrorManager   myErrors;

    fpreal              myExportingTime;
};

#endif // __GLTF_Exporter_h__