GltfLoader.h

Go to the documentation of this file.

#pragma once
#include "BS_tracy_thread_pool.hpp"
#include <Engine/Mesh/Vertex.h>
#include <filesystem>
#include <tiny_gltf.h>
#include <vector>
 
#include "Engine/Ecs/EcsData.h"
#include "Engine/Material/MaterialData.h"
#include "Engine/Renderer/NamedThreadPool.h"
 
namespace EngineCore {
    enum PipelineNames : int;
}
 
namespace EngineCore {
    class AssetManager;
}
 
namespace EngineCore {
    class Texture;
 
    class GltfLoader {
    public:
        GltfLoader(NamedThreadPool *threadPool = nullptr);
 
        ~GltfLoader();
 
 
 
        struct GltfBufferDataView {
            GltfBufferDataView(const std::vector<tinygltf::Buffer>& buffers,
                               const std::vector<tinygltf::BufferView>& bufferViews,
                               const tinygltf::Accessor& accessor);
 
            const tinygltf::Accessor& accessor;
            const tinygltf::BufferView& bufferView;
            const tinygltf::Buffer& buffer;
            const float *data;
        };
 
        struct GltfVertexData {
            GltfVertexData(const std::vector<tinygltf::Buffer> &buffers,
                           const std::vector<tinygltf::BufferView> &bufferViews,
                           const std::vector<tinygltf::Accessor> &accessors, const tinygltf::Primitive &primitive);
            std::optional<GltfBufferDataView> positionDataView;
            std::optional<GltfBufferDataView> normalDataView;
            std::optional<GltfBufferDataView> tangentDataView;  // TANGENT attribute (vec4: xyz=tangent, w=handedness)
            std::optional<GltfBufferDataView> uvDataView;
            std::optional<GltfBufferDataView> lightmapDataView;
            std::optional<GltfBufferDataView> indexDataView;
        };
 
        std::vector<Vertex> getPrimitiveVertices(const tinygltf::Primitive& primitive);
 
        Ecs::PrimitiveData loadPrimitiveData(GltfVertexData vertexData);
 
        struct GltfTextureData {
            GltfTextureData() = default;
 
            GltfTextureData(const tinygltf::Image &image) : image(image) {
            }
 
            [[nodiscard]] tinygltf::Image getImage() const { return image; }
 
            [[nodiscard]] bool hasTextureData() const;
 
        private:
            tinygltf::Image image = tinygltf::Image();
 
        };
 
        struct StaticMeshSettings {
            StaticMeshSettings() = default;
 
            StaticMeshSettings(const tinygltf::Value &extras);
 
            bool bUsesLightMaps = false;
            std::filesystem::path lightMapPath = std::filesystem::path();
            int lightMapUvIndex = std::numeric_limits<int>::max();
        };

        struct VulkanSchneeExtension {
            VulkanSchneeExtension() = default;
 
            explicit VulkanSchneeExtension(const tinygltf::Value& vs_extension);

            struct MeshProperties {
                explicit MeshProperties(const tinygltf::Value& extension);
                bool isStatic;
                bool collisionEnabled;
            };

            struct LightProperties {
                explicit LightProperties(const tinygltf::Value& extension);
 
                struct LightmapProperties {
                    explicit LightmapProperties(const tinygltf::Value& extension);
                    std::filesystem::path lightmapPath;
                    uint32_t lightmapUvIndex;
 
                    bool isLightmapPathValid() const;
                };
 
                bool getCastShadows() const;
                bool getReceiveShadows() const;
                bool getHasLightmaps() const;
 
            private:
 
                std::optional<LightmapProperties> lightmapProperties;
 
                bool castShadows;
                bool receiveShadows;
                bool hasLightmaps;
            };
 
            struct metadata {
 
                std::string blenderObjectName;
            };
 
            std::optional<LightProperties> lightProperties;
            std::optional<MeshProperties> meshProperties;
            std::optional<LightProperties::LightmapProperties> lightmapProperties;
 
            [[nodiscard]] bool hasLightProperties() const;
            [[nodiscard]] bool hasLightmapProperties() const;
            [[nodiscard]] bool hasMeshProperties() const;
 
        private:
            static std::string extractVersion(const tinygltf::Value& vs_extension);
        };

        struct VulkanSchneeMaterialExtension {
            VulkanSchneeMaterialExtension() = default;
 
            explicit VulkanSchneeMaterialExtension(const tinygltf::Value& vs_extension);

            struct ShaderParameter {
                explicit ShaderParameter(const tinygltf::Value& param);
 
                std::string type;        // "connected" or "value"
                std::string socketType;  // Socket type from Blender
                tinygltf::Value value;   // Only valid if type == "value"
            };
 
            std::string shaderType;
            PipelineNames materialName;
 
            std::map<std::string, ShaderParameter> shaderParameters;
            std::map<std::string, double> nodeProperties;
            std::map<std::string, tinygltf::Value> customProperties;
        };

        struct MaterialExtensions {
            MaterialExtensions() = default;
 
            explicit MaterialExtensions(const tinygltf::ExtensionMap &material);
 
            std::optional<VulkanSchneeMaterialExtension> vulkanSchneeMaterialExtension;
        };
 

        struct StaticMeshExtensions {
            StaticMeshExtensions() = default;
            explicit StaticMeshExtensions(const tinygltf::ExtensionMap &extensions);
 
            std::optional<VulkanSchneeExtension> vulkanSchneeExtension;
        };

        struct GltfMaterialData {
            GltfMaterialData() = default;
 
            GltfMaterialData(const tinygltf::Model &model, const tinygltf::Material &material,
                             const StaticMeshExtensions &meshSettings);
 
            [[nodiscard]] tinygltf::Material getMaterial() const { return material; }
 
            [[nodiscard]] bool hasTexture() const;
 
            [[nodiscard]] uint32_t getTextureIndex() const;
 
            [[nodiscard]] GltfTextureData getTextureData() const;
 
            [[nodiscard]] bool hasVulkanSchneeExtension() const;
 
            [[nodiscard]] const VulkanSchneeMaterialExtension& getVulkanSchneeExtension() const;
 
            [[nodiscard]] std::string getShaderName() const;
 
            template<typename T>
            T getMaterialData() const;
 
            std::variant<
                NormalMaterialData,
                DiffuseFlatColorMaterialData,
                DiffuseShaderMaterialData,
                MovableDiffuseShaderMaterialData,
                L0ShaderMaterialData,
                L1ShaderMaterialData,
                L2ShaderMaterialData,
                DynamicTexturesMaterialData,
                StaticLightmapMaterialData
            > getMaterialDataRaw() const;
 
            // PBR texture accessors (0xFFFFFFFF = not present)
            [[nodiscard]] uint32_t getNormalTextureIndex() const { return normalTextureIndex; }
            [[nodiscard]] uint32_t getRoughnessMetallicTextureIndex() const { return roughnessMetallicTextureIndex; }
            [[nodiscard]] uint32_t getEmissiveTextureIndex() const { return emissiveTextureIndex; }
 
            // PBR factor accessors
            [[nodiscard]] float getRoughnessFactor() const { return roughnessFactor; }
            [[nodiscard]] float getMetallicFactor() const { return metallicFactor; }
            [[nodiscard]] float getNormalScale() const { return normalScale; }
            [[nodiscard]] glm::vec3 getEmissiveFactor() const { return emissiveFactor; }
 
            // PBR texture data accessors
            [[nodiscard]] bool hasNormalTexture() const { return gltfNormalTextureIndex >= 0; }
            [[nodiscard]] bool hasMetallicRoughnessTexture() const { return gltfMetallicRoughnessTextureIndex >= 0; }
            [[nodiscard]] bool hasEmissiveTexture() const { return gltfEmissiveTextureIndex >= 0; }
            [[nodiscard]] const GltfTextureData& getNormalTextureData() const { return normalTextureData; }
            [[nodiscard]] const GltfTextureData& getMetallicRoughnessTextureData() const { return metallicRoughnessTextureData; }
            [[nodiscard]] const GltfTextureData& getEmissiveTextureData() const { return emissiveTextureData; }
            [[nodiscard]] int32_t getGltfNormalTextureIndex() const { return gltfNormalTextureIndex; }
            [[nodiscard]] int32_t getGltfMetallicRoughnessTextureIndex() const { return gltfMetallicRoughnessTextureIndex; }
            [[nodiscard]] int32_t getGltfEmissiveTextureIndex() const { return gltfEmissiveTextureIndex; }
 
            // Lightmap texture accessors
            [[nodiscard]] bool hasLightmapTexture() const { return !lightmapPath.empty(); }
            [[nodiscard]] const std::filesystem::path& getLightmapPath() const { return lightmapPath; }
            [[nodiscard]] const GltfTextureData& getLightmapTextureData() const { return lightmapTextureData; }
 
        private:
            void setupMaterialData();
            void parsePbrData(const tinygltf::Model &model, const tinygltf::Material &material);
 
            std::variant<
                NormalMaterialData,
                DiffuseFlatColorMaterialData,
                DiffuseShaderMaterialData,
                MovableDiffuseShaderMaterialData,
                L0ShaderMaterialData,
                L1ShaderMaterialData,
                L2ShaderMaterialData,
                DynamicTexturesMaterialData,
                StaticLightmapMaterialData
            > materialData;
 
            std::optional<MaterialExtensions> materialExtensions;
            tinygltf::Material material = tinygltf::Material();
            glm::vec4 baseColorFactor = glm::vec4(0.0f, 0.0f, 0.0f, 0.0f);
            uint32_t textureIndex = std::numeric_limits<uint32_t>::max();
            GltfTextureData textureData = GltfTextureData();
 
            // PBR texture indices (0xFFFFFFFF = not present)
            uint32_t normalTextureIndex = 0xFFFFFFFF;
            uint32_t roughnessMetallicTextureIndex = 0xFFFFFFFF;
            uint32_t emissiveTextureIndex = 0xFFFFFFFF;
 
            // PBR material factors
            float roughnessFactor = 1.0f;
            float metallicFactor = 0.0f;
            float normalScale = 1.0f;
            glm::vec3 emissiveFactor = glm::vec3(0.0f);
 
            // PBR texture data (image data for loading into descriptor array)
            GltfTextureData normalTextureData;
            GltfTextureData metallicRoughnessTextureData;
            GltfTextureData emissiveTextureData;
 
            // GLTF indices for mapping to texture paths (-1 = not present)
            int32_t gltfNormalTextureIndex = -1;
            int32_t gltfMetallicRoughnessTextureIndex = -1;
            int32_t gltfEmissiveTextureIndex = -1;
 
            // Lightmap texture data (from VulkanSchnee extension, loaded from EXR file)
            std::filesystem::path lightmapPath;
            GltfTextureData lightmapTextureData;
        };

        struct GltfMeshPrimitiveData {
            friend AssetManager;
 
            GltfMeshPrimitiveData() = default;

            GltfMeshPrimitiveData(tinygltf::Model model, tinygltf::Primitive primitive,
                                  StaticMeshExtensions meshSettings);

            [[nodiscard]] std::vector<Vertex> getVertices() const;

            [[nodiscard]] std::vector<uint32_t> getIndices() const;
 
            [[nodiscard]] GltfMaterialData getMaterialData() const;

            [[nodiscard]] Texture *getColorTexturePtr() const;
 
            [[nodiscard]] uint32_t getColorTextureIndex() const;
 
        private:
            uint32_t textureIndex = 0;
            Texture *colorTexturePtr = nullptr;
 
            tinygltf::Primitive primitive;
            GltfMaterialData materialData;
            std::vector<Vertex> vertices;
            std::vector<uint32_t> indices;
        };
 
        struct GltfMeshData {
            GltfMeshData(const tinygltf::Model &model, const tinygltf::Mesh &mesh, const tinygltf::Node &node,
                         const glm::mat4 &transform);
 
            [[nodiscard]] std::vector<GltfMeshPrimitiveData> getPrimitives() const { return primitives; }
            [[nodiscard]] std::vector<GltfMeshPrimitiveData> &getPrimitivesRef() { return primitives; }
            [[nodiscard]] std::string getName() const { return name; }

            [[nodiscard]] glm::mat4 getTransform() const { return transform; }
 
        private:
            std::string name;
            tinygltf::Mesh mesh;
            std::vector<GltfMeshPrimitiveData> primitives;
            glm::mat4 transform;
        };

        void load(const std::filesystem::path &path, std::vector<GltfMeshData> &meshes) const;
 
        std::optional<tinygltf::Model> loadModel(const std::filesystem::path &path) const;
 
        tinygltf::Model loadAsync(const std::filesystem::path &path) const;

        tinygltf::Model loadMetadataOnly(const std::filesystem::path &path) const;
 
    private:
        NamedThreadPool *threadPool = nullptr;
    };
 
    template<typename T>
    T GltfLoader::GltfMaterialData::getMaterialData() const {
        return std::get<T>(materialData);
    }
} // namespace EngineCore