gltf_extensions.h

#ifndef OE_SCENE_LOADER_GLTF_EXTENSIONS_H
#define OE_SCENE_LOADER_GLTF_EXTENSIONS_H
 
#include "../node_ptr.h"
#include "../material.h"
#include "../../lib/json.hpp"
 
namespace oe::scene::gltf
{
    class Extension
    {
        public:
            void applyOnAssetPreload(scene::NodePtr root_node, const nlohmann::json& extension_data)
            {
                // Empty default implementation
 
                (void)root_node;
                (void)extension_data;
            }
 
            void applyOnAssetPostload(scene::NodePtr root_node, const nlohmann::json& extension_data)
            {
                // Empty default implementation
 
                (void)root_node;
                (void)extension_data;
            }
 
            void applyOnNode(scene::NodePtr node, const nlohmann::json& extension_data)
            {
                // Empty default implementation
 
                (void)node;
                (void)extension_data;
            }
 
            void applyOnMaterial(scene::Material& material, const nlohmann::json& extension_data)
            {
                // Empty default implementation
 
                (void)material;
                (void)extension_data;
            }
 
            /*
            std::shared_ptr<GltfLoader> getLoader()
            {
                return _loader;
            }
 
        private:
            std::shared_ptr<GltfLoader> _loader;
 
            friend class GltfLoader;
            */
    };
 
    // TODO: Maybe make this generic and renamd to something like "named_factory"
    // Then put the applyOn*** in GltfExtensionManager::public NamedFactory
 
    template <typename ...ExtensionTypes>
    class ExtensionManager
    {
        public:
            template <typename T, typename... Args>
            void addExtension(const std::string& name, Args&&... args)
            {
                _extensions.emplace(name, std::in_place_type<T>, std::forward<Args>(args)...);
            }
 
            void applyOnAsset(const std::string& name, NodePtr root_node, const nlohmann::json& extension_data, const bool pre_load)
            {
                //OE_APPLY_EXTENSION_ON(Asset, component.applyOnAsset(root_node, extension_data))
 
                if (_extensions.count(name))
                {
                    std::visit([&root_node, &extension_data, &pre_load](auto& extension)
                    {
                        if (pre_load)
                            extension.applyOnAssetPreload(root_node, extension_data);
                        else
                            extension.applyOnAssetPostload(root_node, extension_data);
 
                    }, _extensions.at(name));
                }
            }
 
            void applyOnNode(const std::string& name, NodePtr node, const nlohmann::json& extension_data)
            {
                //OE_APPLY_EXTENSION_ON(node, component.applyOnNode(node, extension_data))
 
                if (_extensions.count(name))
                {
                    std::visit([&node, &extension_data](auto& extension)
                    {
                        extension.applyOnNode(node, extension_data);
                    }, _extensions.at(name));
                }
            }
 
            void applyOnMaterial(const std::string& name, Material& material, const nlohmann::json& extension_data)
            {
                if (_extensions.count(name))
                {
                    std::visit([&material, &extension_data](auto& extension)
                    {
                        extension.applyOnMaterial(material, extension_data);
                    }, _extensions.at(name));
                }
            }
 
        private:
            std::unordered_map<std::string, std::variant<ExtensionTypes...>> _extensions;
    };
}
#endif