GltfLoader.h

#pragma once
#include "Engine/Animation/AnimationAsset.h"
#include "Engine/Animation/SkinAsset.h"
#include "Engine/Ecs/EcsData.h"
#include "Engine/Material/MaterialData.h"
#include "Engine/World/Transform.h"
 
#include <Engine/Mesh/Vertex.h>
#include <filesystem>
#include <glm/gtc/quaternion.hpp>
#include <limits>
#include <tiny_gltf.h>
#include <vector>
 
class NamedThreadPool;
 
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
        {
            struct AnchorPointReference
            {
                std::string name;           
                uint32_t    nodeIndex = 0;  
            };

            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;

                std::string collisionProfile;

                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;
 
            std::vector<AnchorPointReference>                  anchorPoints;  

            [[nodiscard]] bool hasLightProperties() const;

            [[nodiscard]] bool hasLightmapProperties() const;

            [[nodiscard]] bool hasMeshProperties() const;

            [[nodiscard]] bool hasCollisionProperties() const;

            [[nodiscard]] bool hasPointLightProperties() const;

            [[nodiscard]] bool hasDirectionalLightProperties() const;

            [[nodiscard]] bool hasAnchorPoints() 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;
            }

            [[nodiscard]] uint32_t getNormalTextureIndex() const
            {
                return normalTextureIndex;
            }

            [[nodiscard]] uint32_t getRoughnessMetallicTextureIndex() const
            {
                return roughnessMetallicTextureIndex;
            }

            [[nodiscard]] uint32_t getEmissiveTextureIndex() const
            {
                return emissiveTextureIndex;
            }

            [[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;
            }

            [[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;
            }

            [[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