GltfLoader.h

Go to the documentation of this file.

#pragma once
#include "BS_tracy_thread_pool.hpp"
#include "Engine/Animation/AnimationAsset.h"
#include "Engine/Animation/SkinAsset.h"
#include "Engine/Ecs/EcsData.h"
#include "Engine/Entity/SkeletalMeshActor.h"
#include "Engine/Material/MaterialData.h"
#include "Engine/Renderer/NamedThreadPool.h"
#include "Engine/Texture/Ktx2Loader.h"
 
#include <Engine/Mesh/Vertex.h>
#include <filesystem>
#include <glm/gtc/quaternion.hpp>
#include <limits>
#include <tiny_gltf.h>
#include <vector>
 
namespace Engine::Assets
{
    class RuntimeTexture;
    class Texture;
}  // namespace Engine::Assets
 
namespace Engine::Core
{
    class AssetManager;
}  // namespace Engine::Core
 
namespace Engine::Assets::Loaders {
 
    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::optional<GltfBufferDataView> jointsDataView;   
            std::optional<GltfBufferDataView> weightsDataView;  
        };
 
        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,
                                           const tinygltf::Model* model = nullptr);

            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;
                    std::filesystem::path lightmapKtxPath;
                    uint32_t lightmapUvIndex;
 
                    bool isLightmapPathValid() const;
                    [[nodiscard]] const std::filesystem::path& getRuntimeLightmapPath() 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;
            };

            struct CollisionProperties {
                enum class ShapeType { NONE, BOX, SPHERE, CAPSULE, CONVEX_HULL, TRIANGLE_MESH, COMPOUND };
 
                CollisionProperties() = default;
                explicit CollisionProperties(const tinygltf::Value& extension,
                                             const tinygltf::Model* model = nullptr);
 
                ShapeType shapeType = ShapeType::NONE;
                bool generateConvexHull = false;
                bool isTrigger = false;
                glm::vec3 offset{0.0f};
 
                // Primitive params
                glm::vec3 boxHalfExtents{0.5f};
                float sphereRadius = 0.5f;
                float capsuleRadius = 0.5f;
                float capsuleHeight = 1.0f;
 
                // Convex/mesh data
                std::vector<glm::vec3> vertices;
                std::vector<uint32_t> indices;
 
                // Compound children
                struct CompoundChild {
                    std::string name;
                    std::vector<glm::vec3> vertices;
                    std::vector<uint32_t> indices;
                    std::vector<uint32_t> edgeIndices;
                    glm::vec3 offset{0.0f};
                    glm::quat rotation{glm::identity<glm::quat>()};
                };
                std::vector<CompoundChild> compoundChildren;
 
                [[nodiscard]] bool hasCollision() const { return shapeType != ShapeType::NONE; }
 
            private:
                static ShapeType parseShapeType(const std::string& typeStr);
            };
 
            struct PointLightProperties {
                explicit PointLightProperties(const tinygltf::Value& extension);
 
                glm::vec3 color{1.0f};
                float intensity = 1.0f;
                float radius = 10.0f;
                float cullDistance = 100.0f;
            };
 
            struct DirectionalLightProperties {
                explicit DirectionalLightProperties(const tinygltf::Value& extension);
 
                glm::vec3 color{1.0f};
                glm::vec3 direction{0.0f, -1.0f, 0.0f};
                float intensity = 1.0f;
                bool enabled = true;
                bool castsShadows = true;
                bool hasDirection = false;
                float angularDiameterDegrees = 0.53f;
            };
 
            std::optional<LightProperties> lightProperties;
            std::optional<MeshProperties> meshProperties;
            std::optional<LightProperties::LightmapProperties> lightmapProperties;
            std::optional<CollisionProperties> collisionProperties;
            std::optional<PointLightProperties> pointLightProperties;
            std::optional<DirectionalLightProperties> directionalLightProperties;
 
            [[nodiscard]] bool hasLightProperties() const;
            [[nodiscard]] bool hasLightmapProperties() const;
            [[nodiscard]] bool hasMeshProperties() const;
            [[nodiscard]] bool hasCollisionProperties() const;
            [[nodiscard]] bool hasPointLightProperties() const;
            [[nodiscard]] bool hasDirectionalLightProperties() 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;
            Rendering::PipelineNames materialName;
 
            std::map<std::string, ShaderParameter> shaderParameters;
            std::map<std::string, double> nodeProperties;
            std::map<std::string, tinygltf::Value> customProperties;
            bool normalMapBC5 = false;  // True when normal map uses BC5 (2-channel RG)
        };

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

        struct StaticMeshExtensions {
            StaticMeshExtensions() = default;
            explicit StaticMeshExtensions(const tinygltf::ExtensionMap &extensions);
            StaticMeshExtensions(const tinygltf::Model &model, 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]] bool hasTexture() const;
 
            [[nodiscard]] uint32_t getTextureIndex() const;
 
            [[nodiscard]] bool hasVulkanSchneeExtension() const;
 
            [[nodiscard]] const VulkanSchneeMaterialExtension& getVulkanSchneeExtension() const;
 
            [[nodiscard]] std::string getShaderName() const;
 
        [[nodiscard]] const Materials::MaterialData& getMaterialData() const { return materialData; }
        [[nodiscard]] Materials::MaterialData& getMaterialDataRef() { return materialData; }
 
            // 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]] 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; }
 
        private:
        void setupMaterialData();
        void parsePbrData(const tinygltf::Model &model, const tinygltf::Material &material);
 
        Materials::MaterialData materialData;
 
            std::optional<MaterialExtensions> materialExtensions;
            glm::vec4 baseColorFactor = glm::vec4(0.0f, 0.0f, 0.0f, 0.0f);
            uint32_t textureIndex = std::numeric_limits<uint32_t>::max();
 
            // 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);
 
            // GLTF indices for mapping to texture paths (-1 = not present)
            int32_t gltfNormalTextureIndex = -1;
            int32_t gltfMetallicRoughnessTextureIndex = -1;
            int32_t gltfEmissiveTextureIndex = -1;
 
            // Lightmap path (from VulkanSchnee extension)
            std::filesystem::path lightmapPath;
        };

        struct GltfMeshPrimitiveData {
            friend class Core::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]] RuntimeTexture *getColorTexturePtr() const;
 
            [[nodiscard]] uint32_t getColorTextureIndex() const;
 
            [[nodiscard]] const std::vector<BoneVertexData>& getBoneVertexData() const { return boneVertexData; }
            [[nodiscard]] bool hasSkinData() const { return !boneVertexData.empty(); }
 
        private:
            uint32_t textureIndex = std::numeric_limits<uint32_t>::max();
            RuntimeTexture *colorTexturePtr = nullptr;
 
            tinygltf::Primitive primitive;
            GltfMaterialData materialData;
            std::vector<Vertex> vertices;
            std::vector<uint32_t> indices;
            std::vector<BoneVertexData> boneVertexData;  
        };
 
        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; }
 
            [[nodiscard]] int getSkinIndex() const { return skinIndex; }
 
        private:
            std::string name;
            tinygltf::Mesh mesh;
            std::vector<GltfMeshPrimitiveData> primitives;
            glm::mat4 transform;
            int skinIndex = -1;  
        };

        static Assets::Skin loadSkinData(const tinygltf::Model& model, int skinIndex);

        static Animation loadAnimationData(const tinygltf::Model& model, int animIndex, const Assets::Skin& skin);

        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;
    };
} // namespace Engine::Assets::Loaders