gltf.h

#ifndef OE_SCENE_LOADER_GLTF_H
#define OE_SCENE_LOADER_GLTF_H
 
#include "../../lib/json_fwd.hpp"
#include <functional>
#include <variant>
#include "base.h"
#include "../node/multi_mesh.h"
#include "../mesh.h"
 
#include "gltf_extensions.h"
 
namespace oe::scene
{
    class SkinnedMeshNode;
}
 
namespace oe::render
{
    class TextureManager;
}
 
namespace tinygltf
{
    class TinyGLTF;
    class Model;
}
 
namespace oe::scene::loader
{
    class Gltf : public BaseLoader
    {
        public:
            Gltf(const std::string& filename);
            Gltf(Gltf&&);
 
            ~Gltf();
 
            oe::scene::Node& addIntoSceneManager(oe::scene::Manager& scene_manager, uint16_t id_scene = 0);
 
            oe::scene::Node& addIntoSceneManager(oe::scene::Manager& scene_manager, oe::scene::Node& root_node, uint16_t id_scene = 0);
 
            void convertTextures(render::TextureManager&);
 
            void setMaterialFiller(std::function<void(const PbrMaterial& gltf_material, Material& oe_material)>);
 
            void setNodeMaterialModifier(std::function<void(Node& node, Material& node_material)>);
 
            std::vector<Material> getMaterials();
 
            //void setOnTexture(???);
 
            /*std::shared_ptr<oe::scene::Node>& getScene(uint16_t i)
            {
                return _scenes.at(i);
            }
 
            std::shared_ptr<oe::scene::Node>& getNode(uint16_t i)
            {
                return _nodes.at(i);
            }
 
            std::shared_ptr<oe::scene::Material>& getMaterial(uint16_t i = 0);
 
            std::shared_ptr<oe::scene::SkinnedMeshNode>& getSkinnedNode(uint16_t i = 0);*/
 
        protected:
            Gltf();
 
            std::vector<std::shared_ptr<oe::scene::Node>> _scenes;
 
            // Todo clean unused members...
            //std::vector<oe::scene::Node*> _nodes;
           /* std::vector<std::shared_ptr<oe::scene::SkinnedMeshNode>> _skinned_nodes;
*/
           // std::vector<std::shared_ptr<oe::scene::Material>> _materials;
 
            // For each mesh, contain the primitive data + material id
            // Maybe make a difference between classic vertex and skinned primitives ?
 
            // For each mesh, contains the primitive data + material id
            std::unordered_map<uint32_t, std::list<std::pair<std::shared_ptr<oe::scene::Mesh>, int32_t>>> _meshes;
 
            // For each skinned mesh, contains the primitive data + material id
            std::unordered_map<uint32_t, std::list<std::pair<std::shared_ptr<oe::scene::SkinnedMesh>, int32_t>>> _skinned_meshes;
 
            // For each skinned, contain the skinnedMeshNode + skin id
            std::unordered_map<oe::scene::SkinnedMeshNode*, uint32_t> _skinned_nodes_skins;
 
    //        std::vector<oe::scene::MultiMeshNode> _meshes;
            //std::vector<oe::scene::MultiSkinnedMeshNode> _skinned_meshes;
            // OU
            //std::vector<oe::scene::MultiMeshNode<Mesh>> _skinned_meshes;
 
            std::vector<std::shared_ptr<oe::render::Texture>> _textures;
 
            std::function<void(const PbrMaterial&, Material&)> _material_filler = {};
            std::function<void(Node& node, Material& node_material)> _node_material_modifier = {};
 
            oe::scene::Material _default_material;
 
            std::unique_ptr<tinygltf::TinyGLTF> _loader;
            std::unique_ptr<tinygltf::Model> _model;
 
            void _custom_load(const std::string& filename);
 
            std::function<void(const std::string& extension, Node& root_node, const nlohmann::json& extension_data, const bool pre_load)> _custom_asset_extension_handler = {};
            std::function<void(const std::string& extension, Node& node, const nlohmann::json& extension_data)> _custom_node_extension_handler = {};
            std::function<void(const std::string& extension, Material& material, const nlohmann::json& extension_data)> _custom_material_extension_handler = {};
    };
 
    template <typename ExtensionManager = gltf::ExtensionManager<gltf::Extension>>
    class GltfWithExtensions : public Gltf
    {
        public:
            GltfWithExtensions(const ExtensionManager& extension_manager):
                Gltf(),
                extensions(extension_manager)
            {
                _custom_asset_extension_handler = [this] (const std::string& extension, Node& root_node, const nlohmann::json& extension_data, const bool pre_load)
                {
                    extensions.applyOnAsset(extension, root_node, extension_data, pre_load);
                };
 
                _custom_node_extension_handler = [this] (const std::string& extension, Node& node, const nlohmann::json& extension_data)
                {
                    extensions.applyOnNode(extension, node, extension_data);
                };
            }
 
            void load(const std::string& filename)
            {
                _custom_load(filename);
            }
 
            ExtensionManager extensions;
    };
}
 
#endif