GLTF_Translator.h

Go to the documentation of this file.

#ifndef __GLTF_Translator_h__
#define __GLTF_Translator_h__

#include "GLTFZ_API.h"

#include "GLTF_Types.h"

#include <GA/GA_Types.h>
#include <UT/UT_Array.h>
#include <GU/GU_DetailHandle.h>
#include <UT/UT_Map.h>
#include <UT/UT_Matrix4.h>
#include <UT/UT_Quaternion.h>
#include <UT/UT_Vector.h>
#include <UT/UT_VectorTypes.h>

class GEO_PrimCamera;
class GLTF_ErrorManager;
class GLTF_Reader;
class GLTF_Writer;
class GU_Detail;
class GU_PrimPacked;
class IMG_Format;
class OBJ_Camera;
class OBJ_Light;
class OBJ_Node;
class OP_Node;
class SOP_Node;
class UT_OptionsHolder;

class GLTFZ_API GLTF_Translator 
{
public:
    enum class ImportSpace
    {
        World,
        Object
    };

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

    enum class NodeGeometryImportMethod
    {
        PackedPrimitive,
        FlattenedGeometry
    };

    struct MeshImportOptions
    {
        bool                    promotePointAttribs                 = false;
        bool                    addNameAttrib                       = false;
        bool                    importApplicationSpecificAttribs    = true;
    };

    struct MaterialImportOptions
    {
        UT_StringHolder         materialNodePath;
    };

    struct ImportOptions
    {
        MeshImportOptions           myMeshImportOptions;
        MaterialImportOptions       myMaterialImportOptions;
        ImportSpace                 myImportSpace = ImportSpace::World;
        NodeGeometryImportMethod    myNodeGeometryImportMethod =
                                        NodeGeometryImportMethod::PackedPrimitive;
        UT_StringHolder             myPathAttrib;

        bool                        myImportNames = true;
        // This should be set by the user to inform the translator from what
        // level we are importing from
        ImportLevel                 myImportLevel;

        bool                        myImportExtras = true;
    };

    struct Node
    {
        GLTF_Index              myId;

        bool                    myIsRoot;
        
        // You must check myIsRoot before trying to use myParent
        GLTF_Index              myParent;
        UT_Array<GLTF_Index>    myChildren;

        GA_Offset               myPointOffset;

        UT_StringHolder         myName;
        UT_StringHolder         myPath;

        bool                    myHasStaticMatrixTransform;
        UT_Matrix4F             myMatrixTransform;

        UT_Vector3F             myRestTranslation;
        UT_Quaternion           myRestRotation;
        UT_Vector3F             myRestScale;
    };

    static void                     init();
    static void                     uninit();

    static bool                     importSkeleton(GU_Detail *gdp,
                                            GLTF_Reader* gltf_reader,
                                            const GLTF_Index root_node,
                                            UT_Map<GLTF_Index, Node>& joints,
                                            GLTF_ErrorManager& errors); 

    static bool                     importSkinnedMesh(GU_Detail *gdp, 
                                            GLTF_Reader *gltf_reader,
                                            const GLTF_Index node_idx,
                                            const ImportOptions& options,
                                            GLTF_ErrorManager& errors);

    // Creates detail attributes to build a skeleton of the character's capture pose.
    static  bool                    createCapturePoseAttributes(GU_Detail *gdp,
                                            const GLTF_Reader &gltf_reader,
                                            const GLTF_Index node_idx,
                                            GLTF_ErrorManager& errors);

    // Materials
    static bool                     importMaterial(GU_Detail* gdp,
                                            const GLTF_Reader* gltf_reader,
                                            const GLTF_Index mat_idx,
                                            const ImportOptions& options,
                                            GLTF_ErrorManager& errors);

    static bool                     importMeshPrimitive(GU_Detail *prim_gdp,
                                            GLTF_Reader& gltf_reader,
                                            const GLTF_Index mesh_idx,
                                            const GLTF_Index prim_idx,
                                            const ImportOptions& options,
                                            GLTF_ErrorManager& errors);

    static GU_DetailHandle          importMeshPrimitive(
                                            GLTF_Reader& gltf_reader,
                                            const GLTF_Index mesh_idx,
                                            const GLTF_Index prim_idx,
                                            const ImportOptions& options,
                                            GLTF_ErrorManager& errors);

private:

    static bool                     addPointAttribute(GU_Detail *gdp,
                                            GLTF_Reader &gltf_reader,
                                            const GLTF_Index attrib_access_idx,
                                            const char* attrib_name,
                                            GLTF_ErrorManager& errors);

    static bool                     doesURIContainEmbeddedData(
                                            const UT_StringHolder& uri);

    static bool                     addGltfDetailAttrib(GU_Detail* gdp,
                                            GLTF_Reader& gltf_reader,
                                            const UT_StringHolder& attrib_name,
                                            const UT_StringHolder& value,
                                            GLTF_ErrorManager& errors);

    static bool                     addGltfPrimitiveAttrib(GU_Detail* gdp,
                                            GLTF_Reader& gltf_reader,
                                            const UT_StringHolder& attrib_name,
                                            const UT_StringHolder& value,
                                            GLTF_ErrorManager& errors);

    static bool                     addGltfExtrasDictAttrib(GU_Detail* gdp,
                                            GLTF_Reader& gltf_reader,
                                            const UT_StringHolder& attrib_name,
                                            const UT_OptionsHolder& dict_value,
                                            GA_AttributeOwner owner,
                                            GLTF_ErrorManager& errors);
};

#endif // __GLTF_Translator_h__