GLTF_Reader.h

Go to the documentation of this file.

#ifndef __GLTF_Reader_h__
#define __GLTF_Reader_h__

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

#include <UT/UT_StringHolder.h>
#include <UT/UT_UniquePtr.h>

class GLTF_CgltfWrapper;
class GLTF_ErrorManager;

class GLTFZ_API GLTF_Reader
{
// File Reading
public:

    GLTF_Reader() {};
    GLTF_Reader(const char *filePath);
    ~GLTF_Reader() {};

    bool                            loadFile(GLTF_ErrorManager& errors);

    bool                            closeFile();

    bool                            isOpen() const;

    bool                            loadBuffer(const GLTF_Index buf_idx, 
                                            GLTF_ErrorManager& errors);

    bool                            loadAccessorData(const GLTF_Index accessor_idx,
                                                unsigned char** out_data,
                                                GLTF_ErrorManager& errors);

    bool                            loadBufferViewData(
                                            const GLTF_Index bv_idx,
                                            unsigned char** out_data,
                                            GLTF_ErrorManager& errors);

    bool                            loadAnimationData(
                                            const GLTF_Index anim_idx,
                                            GLTF_ErrorManager& errors);

    void                            setFilePath(const char* path)
                                        { myFilePath = path; }
    const UT_StringHolder&          filePath() const { return myFilePath; }

    bool                            isImporterExtensionSupported(
                                        const UT_StringHolder& name) const;

    cgltf_data*                     getCgltfData()
    {
        return myIO.getCgltfData();
    }
    const cgltf_data*               getCgltfData() const
    {
        return myIO.getCgltfData();
    }
    
// Getters
public:

    enum NodeFilter
    {
        ALL,
        SKINNED_MESH
    };

    bool                            getAnimationNames(
                                            UT_StringArray& names,
                                            GLTF_ErrorManager& errors);

    bool                            getScenes(
                                            UT_StringArray& names,
                                            UT_Array<GLTF_Index>& ids,
                                            GLTF_ErrorManager& errors);

    bool                            getNodes(
                                            UT_StringArray& names,
                                            UT_Array<GLTF_Index>& ids,
                                            GLTF_ErrorManager& errors,
                                            NodeFilter filter=NodeFilter::ALL);

    bool                            getMeshes(
                                            UT_StringArray& names,
                                            UT_Array<GLTF_Index>& ids,
                                            GLTF_ErrorManager& errors);

    bool                            getPrimitives(
                                            GLTF_Index mesh_id,
                                            UT_Array<GLTF_Index>& prim_ids,
                                            GLTF_ErrorManager& errors);

    bool                            getMaterials(
                                            GLTF_Index material_id,
                                            UT_StringArray& names,
                                            UT_Array<GLTF_Index>& mat_ids,
                                            GLTF_ErrorManager& errors) const;

    bool                            getRequiredExtensions(
                                            UT_StringArray& ext_names) const;

    // Gets the global transform of a node
    bool                            getNodeTransform(
                                            const GLTF_Index node_idx,
                                            UT_Matrix4& transform,
                                            GLTF_ErrorManager& errors);

public:

    // Validity
    bool                            checkAnimIsValid(
                                            const GLTF_Index anim_id) const;

private:

    GLTF_IO                         myIO{GLTF_IO::Mode::Read};

    UT_StringHolder                 myFilePath;
};

#endif // __GLTF_Reader_h__