gltf.h

#ifndef OE_SCENE_LOADER_GLTF_H
#define OE_SCENE_LOADER_GLTF_H
 
#include "../../lib/json.hpp"
#include <functional>
#include "../skin.h"
#include "../mesh.h"
#include "../camera.h"
#include "../lighting.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
{
    struct GltfPbrMaterial
    {
        glm::vec4 albedoColor = glm::vec4(1.0);
 
        glm::vec3 emissiveColor = glm::vec4(0.0);
 
        glm::vec3 rouMetAoColor = glm::vec3(1.0);
 
        oe::render::Texture* albedoTexture = nullptr;
 
        oe::render::Texture* emissiveTexture = nullptr;
 
        oe::render::Texture* normalTexture = nullptr;
 
        oe::render::Texture* rouMetAoTexture = nullptr;
 
        bool use_pbr = true;
    };
 
    class Gltf
    {
        public:
            Gltf(const std::string& filename);
 
            ~Gltf();
 
            using MeshFlags = uint8_t;
 
            struct GltfSceneData
            {
                // Solid Mesh by ids
                std::map<size_t, scene::SolidMesh> solid_meshes;
 
                // Skinned Mesh by mesh ids
                std::map<size_t, scene::SkinnedMesh> skinned_meshes;
 
                // Armature by node
                std::map<NodePtr, scene::skin::Armature> skins;
 
                // Nodes containing a camera
                std::vector<std::pair<NodePtr, scene::Camera>> cameras;
 
                // Nodes containing a light
                std::vector<std::pair<NodePtr, scene::PointLight>> point_lights;
 
                // Vector and not map because a mesh can be used by many nodes
                // pair first is the node related to the mesh, second is the mesh id
                std::vector<std::pair<NodePtr, size_t>> render_mesh_nodes;
 
                // For next 3 vectors, sizes are count of meshes, vector position is id_mesh
                std::vector<bool> render_mesh_is_skinned;
 
                // Second vector position is material position in mesh, then final one are id_materials
                std::vector<std::vector<ssize_t>> render_meshs_material_ids;
 
                // Don't be afraid: This is "primitives_by_material" member for each mesh
                // Second vector position is id_material, then final one are enabled primitives
                std::vector<std::vector<std::vector<bool>>> render_meshs_material_target;
            };
 
            GltfSceneData convertSceneData(oe::scene::NodePtr root_node, uint16_t id_scene = 0) const;
 
 
            //oe::scene::NodePtr addIntoScene(oe::scene::Scene& scene, oe::scene::NodePtr root_node, uint16_t id_scene = 0);
 
            struct GltfTextureList
            {
                std::vector<oe::render::Texture*> imported;
 
                std::map<size_t, oe::render::Texture*> rou_met_ao;
            };
 
            GltfTextureList convertTextures(render::TextureManager& texture_manager, std::string_view prefix) const;
 
            void setMaterialFiller(std::function<void(const GltfPbrMaterial& gltf_material, Material& oe_material)> material_filler)
            {
                _material_filler = material_filler;
            }
 
            std::vector<Material> convertMaterials(GltfTextureList textures) const;
 
            Material generateDefaultMaterial() const;
 
            /*static constexpr const char* getGltfShaderSurfaceCode()
            {
                return R"(
                    uniform sampler2D uAlbedo;
 
                    void surface(in SurfaceInput surface_input, inout SurfaceOutput result)
                    {
                        result.albedo = texture(uAlbedo, surface_input.tex_coords_0);
 
                        if (result.albedo.a < 0.5)
                            discard;
 
                        result.normal = vec3(0, 0, 1);
                    }
                )";
            }*/
 
            //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::SolidMesh>, 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<oe::render::Texture*> _textures;
 
            std::function<void(const GltfPbrMaterial&, Material&)> _material_filler = {};
            //std::function<void(Node& node, Material& node_material)> _node_material_modifier = {};
 
            //oe::scene::Material _default_material;
 
            tinygltf::TinyGLTF* _loader;
            tinygltf::Model* _model;
 
            void _custom_load(const std::string& filename);
 
            std::function<void(const std::string& extension, NodePtr root_node, const nlohmann::json& extension_data, const bool pre_load)> _custom_asset_extension_handler = {};
            std::function<void(const std::string& extension, NodePtr 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, NodePtr 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, NodePtr node, const nlohmann::json& extension_data)
                {
                    extensions.applyOnNode(extension, node, extension_data);
                };
            }
 
            void load(const std::string& filename)
            {
                _custom_load(filename);
            }
 
            ExtensionManager extensions;
    };
}
 
#endif