GLTF_Importer.h

Go to the documentation of this file.

#ifndef __GLTF_Importer_h__
#define __GLTF_Importer_h__

#include "GLTFZ_API.h"

#include "GLTF_AnimationData.h"
#include "GLTF_ErrorManager.h"
#include "GLTF_ImportOptions.h"
#include "GLTF_SceneData.h"
#include "GLTF_Reader.h"

#include <GA/GA_Types.h>
#include <GU/GU_DetailHandle.h>
#include <UT/UT_Optional.h>
#include <UT/UT_SharedPtr.h>

class GLTF_Codec;
class GU_Detail;

class GLTFZ_API GLTF_Importer
{
private:

    enum class ImportLevel
    {
        Scene,
        Node,
        Mesh,
        Primitive,
        Materials
    };

public:
    void setGltfFile(const char* filepath)
    {
        myReader.setFilePath(filepath);
    }

    const GLTF_Reader& getReader() { return myReader; }
    GLTF_ImportOptions& getImportOptions() { return myOptions; }
    const GLTF_AnimationData& getAnimationData() const { return myAnimData; }
    const GLTF_SceneData& getSceneData() const { return myScene; }
    const GLTF_ErrorManager& getErrors() const { return myErrors; }

public:

    bool                importScene(
                                GU_Detail& gdp,
                                const GLTF_Index scene_idx);

    bool                importNode(
                                GU_Detail& gdp,
                                const GLTF_Index node_idx);

    bool                importMesh(
                                GU_Detail& gdp,
                                const GLTF_Index mesh_idx);

    bool                importMeshPrimitive(
                                GU_Detail& prim_gdp,
                                const GLTF_Index mesh_idx,
                                const GLTF_Index prim_idx);

    bool                importMaterial(
                                GU_Detail& gdp,
                                const GLTF_Index mat_idx);

private:

    bool                doImportScene(
                                GU_Detail& gdp,
                                const GLTF_Index scene_idx);

    bool                doImportNode(
                                GU_Detail& gdp,
                                const GLTF_Index node_idx);

    GU_DetailHandle     doImportNode(
                                const GLTF_Index node_idx);

    bool                doImportCamera(
                                GU_Detail& gdp,
                                const GLTF_Index node_idx,
                                const GLTF_Index cam_idx);

    bool                doImportMesh(
                                GU_Detail& gdp,
                                const GLTF_Index mesh_idx,
                                const GLTF_WindingOrder winding_order);

    bool                doImportMeshPrimitive(
                                GU_Detail& prim_gdp,
                                const GLTF_Index mesh_idx,
                                const GLTF_Index prim_idx,
                                const GLTF_WindingOrder winding_order);

    GU_DetailHandle     doImportMeshPrimitive(
                                const GLTF_Index mesh_idx,
                                const GLTF_Index prim_idx,
                                const GLTF_WindingOrder winding_order);

    bool                doImportAnimations();

    bool                doImportMaterial(
                                GU_Detail& gdp,
                                const GLTF_Index mat_idx);

private:

    void                traverseNodeGraph(
                                const GLTF_Index node_idx,
                                UT_Array<GLTF_Index>& traversed,
                                UT_Optional<GLTF_Index> end_node);

    bool                addStringAttributeUniformVal(
                                GU_Detail& gdp,
                                const char* attrib_name,
                                const char* attrib_val,
                                GA_AttributeOwner owner) const; 

    bool                addDictAttributeUniformVal(
                                GU_Detail& gdp,
                                const char* attrib_name,
                                const UT_OptionsHolder& attrib_val,
                                GA_AttributeOwner owner) const;

    bool                checkRequiredExtensionsAreSupportedOrIgnored();

private:

    UT_SharedPtr<GLTF_Codec>
                        createMatchingMeshCodec(bool is_draco_mesh);
    UT_SharedPtr<GLTF_Codec>
                        createMatchingMaterialCodec();

private:
    GLTF_Reader         myReader;
    GLTF_ImportOptions  myOptions;
    GLTF_ErrorManager   myErrors;
    GLTF_AnimationData  myAnimData;
    GLTF_SceneData      myScene;

    ImportLevel         myImportLevel;
};

#endif // __GLTF_Importer_h__