Loading Models: Implementing the Model Loading System

// Include tinygltf for model loading
#include <tiny_gltf.h>

// Vertex structure with position, normal, color, and texture coordinates
struct Vertex {
    glm::vec3 pos;
    glm::vec3 normal;
    glm::vec3 color;
    glm::vec2 texCoord;

    // Binding and attribute descriptions for Vulkan
    static vk::VertexInputBindingDescription getBindingDescription() {
        return { 0, sizeof(Vertex), vk::VertexInputRate::eVertex };
    }

    static std::array<vk::VertexInputAttributeDescription, 4> getAttributeDescriptions() {
        return {
            vk::VertexInputAttributeDescription( 0, 0, vk::Format::eR32G32B32Sfloat, offsetof(Vertex, pos) ),
            vk::VertexInputAttributeDescription( 1, 0, vk::Format::eR32G32B32Sfloat, offsetof(Vertex, normal) ),
            vk::VertexInputAttributeDescription( 2, 0, vk::Format::eR32G32B32Sfloat, offsetof(Vertex, color) ),
            vk::VertexInputAttributeDescription( 3, 0, vk::Format::eR32G32Sfloat, offsetof(Vertex, texCoord) )
        };
    }

    // Equality operator and hash function for vertex deduplication
    bool operator==(const Vertex& other) const {
        return pos == other.pos && normal == other.normal && color == other.color && texCoord == other.texCoord;
    }
};

// Structure for PBR material properties
struct Material {
    glm::vec4 baseColorFactor = glm::vec4(1.0f);
    float metallicFactor = 1.0f;
    float roughnessFactor = 1.0f;
    glm::vec3 emissiveFactor = glm::vec3(0.0f);

    int baseColorTextureIndex = -1;
    int metallicRoughnessTextureIndex = -1;
    int normalTextureIndex = -1;
    int occlusionTextureIndex = -1;
    int emissiveTextureIndex = -1;
};

// Structure for a mesh with vertices, indices, and material
struct Mesh {
    std::vector<Vertex> vertices;
    std::vector<uint32_t> indices;
    int materialIndex = -1;
};

// Structure for a node in the scene graph
struct Node {
    Node* parent = nullptr;
    std::vector<Node*> children;
    Mesh mesh;
    glm::mat4 matrix = glm::mat4(1.0f);

    // For animation
    glm::vec3 translation = glm::vec3(0.0f);
    glm::quat rotation = glm::quat(1.0f, 0.0f, 0.0f, 0.0f);
    glm::vec3 scale = glm::vec3(1.0f);

    glm::mat4 getLocalMatrix() {
        return glm::translate(glm::mat4(1.0f), translation) *
               glm::toMat4(rotation) *
               glm::scale(glm::mat4(1.0f), scale) *
               matrix;
    }

    glm::mat4 getGlobalMatrix() {
        glm::mat4 m = getLocalMatrix();
        Node* p = parent;
        while (p) {
            m = p->getLocalMatrix() * m;
            p = p->parent;
        }
        return m;
    }
};

// Structure for animation keyframes
struct AnimationChannel {
    enum PathType { TRANSLATION, ROTATION, SCALE };
    PathType path;
    Node* node = nullptr;
    uint32_t samplerIndex;
};

// Structure for animation interpolation
struct AnimationSampler {
    enum InterpolationType { LINEAR, STEP, CUBICSPLINE };
    InterpolationType interpolation;
    std::vector<float> inputs;  // Key frame timestamps
    std::vector<glm::vec4> outputsVec4;  // Key frame values (for rotations)
    std::vector<glm::vec3> outputsVec3;  // Key frame values (for translations and scales)
};

// Structure for animation
struct Animation {
    std::string name;
    std::vector<AnimationSampler> samplers;
    std::vector<AnimationChannel> channels;
    float start = std::numeric_limits<float>::max();
    float end = std::numeric_limits<float>::min();
    float currentTime = 0.0f;
};

// Structure for a model with nodes, meshes, materials, textures, and animations
struct Model {
    std::vector<Node*> nodes;
    std::vector<Node*> linearNodes;
    std::vector<Material> materials;
    std::vector<Animation> animations;

    ~Model() {
        for (auto node : linearNodes) {
            delete node;
        }
    }

    Node* findNode(const std::string& name) {
        auto nodeIt = std::ranges::find_if(linearNodes, [&name](auto const& node) {
            return node->name == name;
        });
        return (nodeIt != linearNodes.end()) ? *nodeIt : nullptr;
    }

    void updateAnimation(uint32_t index, float deltaTime) {
        assert(!animations.empty() && index < animations.size());



        Animation& animation = animations[index];
        animation.currentTime += deltaTime;
        if (animation.currentTime > animation.end) {
            animation.currentTime = animation.start;
        }

        for (auto& channel : animation.channels) {
            AnimationSampler& sampler = animation.samplers[channel.samplerIndex];

            // Find the current key frame using binary search
            auto keyFrameIt = std::ranges::lower_bound(sampler.inputs, animation.currentTime);
            if (keyFrameIt != sampler.inputs.end() && keyFrameIt != sampler.inputs.begin()) {
                size_t i = std::distance(sampler.inputs.begin(), keyFrameIt) - 1;
                float t = (animation.currentTime - sampler.inputs[i]) / (sampler.inputs[i + 1] - sampler.inputs[i]);

                    switch (channel.path) {
                        case AnimationChannel::TRANSLATION: {
                            glm::vec3 start = sampler.outputsVec3[i];
                            glm::vec3 end = sampler.outputsVec3[i + 1];
                            channel.node->translation = glm::mix(start, end, t);
                            break;
                        }
                        case AnimationChannel::ROTATION: {
                            glm::quat start = glm::quat(sampler.outputsVec4[i].w, sampler.outputsVec4[i].x, sampler.outputsVec4[i].y, sampler.outputsVec4[i].z);
                            glm::quat end = glm::quat(sampler.outputsVec4[i + 1].w, sampler.outputsVec4[i + 1].x, sampler.outputsVec4[i + 1].y, sampler.outputsVec4[i + 1].z);
                            channel.node->rotation = glm::slerp(start, end, t);
                            break;
                        }
                        case AnimationChannel::SCALE: {
                            glm::vec3 start = sampler.outputsVec3[i];
                            glm::vec3 end = sampler.outputsVec3[i + 1];
                            channel.node->scale = glm::mix(start, end, t);
                            break;
                        }
                    }
                    break;
                }
            }
        }
    }
};