GltfMeshLoader.cpp

Go to the documentation of this file.

#include "Engine/Mesh/GltfMeshLoader.h"
#include "tiny_gltf.h"
#include <filesystem>
#include <optional>
#include <plog/Log.h>
 
#include "Engine/Mesh/Vertex.h"
#include "Engine/Texture/TextureLoader.h"
#include "Engine/Texture/Texture.h"
 
namespace EngineCore {
    void MeshLoaderGltf::useDefaultTexture(std::vector<std::unique_ptr<TextureLoadData>> &textureLoadData) {
        TextureLoader textureLoader = TextureLoader();
 
        for (int i = 0; i < Mesh::getTextureCount(); i++) {
            textureLoadData.push_back(textureLoader.loadImage("textures/DefaultGrid.png"));
        }
    }
 
    void MeshLoaderGltf::loadMesh(const std::filesystem::path &filePath, std::vector<Vertex> &vertices, std::vector<uint32_t> &indices,
                                  std::vector<std::unique_ptr<TextureLoadData>>& textureLoadData) {
        tinygltf::Model model;
        tinygltf::TinyGLTF loader;
 
        if (filePath.generic_string().length() == 0) {
            throw std::runtime_error(std::string("missing file path to mesh with filepath: ") + filePath.generic_string());
        }
 
        if (!exists(filePath)) {
            throw::std::runtime_error(std::string("Path does not exist! ") + filePath.generic_string() + std::string(" from this directory: ") + std::filesystem::current_path().generic_string());
            return;
        }
 
        model = getModel(filePath, model, loader);
 
        // Load textures first to avoid duplicates
        std::unordered_map<int, int> textureMap; // Maps texture index to texture vector index
 
        for (auto& mesh : model.meshes) {
            PLOGI << "Loading " << mesh.primitives.size() << "primitives";
            for (auto& primitive : mesh.primitives) {
                if (primitive.mode != TINYGLTF_MODE_TRIANGLES) {
                    PLOGE << "Non-Triangles found! Skipping!";
                    continue;
                }
 
                for (auto attribute : primitive.attributes) {
                    PLOGI << attribute.first;
                }
 
                // access position of the vertices
                auto positionIterator = primitive.attributes.find("POSITION");
                if (positionIterator == primitive.attributes.end()) {
                    PLOGE << "POSITION attribute not found! Skipping primitive.";
                    continue;
                }
 
                const tinygltf::Accessor& positionAccessor = model.accessors[positionIterator->second];
                const tinygltf::BufferView& positionView = model.bufferViews[positionAccessor.bufferView];
                const tinygltf::Buffer& positionBuffer = model.buffers[positionView.buffer];
                const float* positions = reinterpret_cast<const float*>(&(positionBuffer.data[positionView.byteOffset + positionAccessor.byteOffset]));
 
                // access NORMAL
                auto normalIterator = primitive.attributes.find("NORMAL");
                if (normalIterator == primitive.attributes.end()) {
                    PLOGE << "NORMAL attribute not found! Skipping primitive.";
                    continue;
                }
 
                const tinygltf::Accessor& normalAccessor = model.accessors[normalIterator->second];
                const tinygltf::BufferView& normalView = model.bufferViews[normalAccessor.bufferView];
                const tinygltf::Buffer& normalBuffer = model.buffers[normalView.buffer];
                const float* normals = reinterpret_cast<const float*>(&(normalBuffer.data[normalView.byteOffset + normalAccessor.byteOffset]));
 
                // Texture coordinate
                auto textureCoordinateIterator = primitive.attributes.find("TEXCOORD_0");
                if (textureCoordinateIterator == primitive.attributes.end()) {
                    PLOGE << "TEXCOORD_0 attribute not found! Skipping primitive.";
                    continue;
                }
 
                const tinygltf::Accessor& textureCoordinateAccessor = model.accessors[textureCoordinateIterator->second];
                const tinygltf::BufferView& textureCoordinateView = model.bufferViews[textureCoordinateAccessor.bufferView];
                const tinygltf::Buffer& textureCoordinateBuffer = model.buffers[textureCoordinateView.buffer];
                const float* textureCoordinates = reinterpret_cast<const float*>(&(textureCoordinateBuffer.data[textureCoordinateView.byteOffset + textureCoordinateAccessor.byteOffset]));
 
                // textures
                if (primitive.material >= 0 && primitive.material < model.materials.size()){
                    const tinygltf::Material& material = model.materials[primitive.material];
 
                    // base color
                    if (material.pbrMetallicRoughness.baseColorTexture.index >= 0 &&
                        material.pbrMetallicRoughness.baseColorTexture.index < model.textures.size()
                    )
                    {
                        int textureIndex = material.pbrMetallicRoughness.baseColorTexture.index;
 
                        const tinygltf::Texture& texture = model.textures[textureIndex];
                        if (texture.source < 0 || texture.source >= model.images.size()) {
                            PLOGE << "Invalid textureData source index: " << texture.source;
                            continue;
                        }
 
                        const tinygltf::Image& img = model.images[texture.source];
 
                        if (img.image.empty()) {
                            PLOGE << "Image data is empty for textureData: " << filePath.generic_string();
                            continue;
                        }
 
                        std::unique_ptr<TextureLoadData> textureData = std::make_unique<TextureLoadData>(img.image, img.width, img.height, img.component);
                        PLOGI << "Loaded textureData: " << filePath.generic_string() << " (" << textureData->width << "x" << textureData->height << ")";
 
                        // Store the textureData
                        textureLoadData.push_back(std::move(textureData));
                        textureMap[textureIndex] = textureLoadData.size() - 1;
 
                    }
                    else {
                        useDefaultTexture(textureLoadData);
                    }
                }
                else {
                    // default texture if main texture is missing
                    useDefaultTexture(textureLoadData);
 
                }
 
                // indices
                const tinygltf::Accessor& indicesAccessor = model.accessors[primitive.indices];
                const tinygltf::BufferView& indicesView = model.bufferViews[indicesAccessor.bufferView];
                const tinygltf::Buffer& indicesBuffer = model.buffers[indicesView.buffer];
                const void* indicesPointer = &(indicesBuffer.data[indicesView.byteOffset + indicesAccessor.byteOffset]);
 
                // convert indices to uint32_t
                std::vector<uint32_t> convertedIndices;
                if (indicesAccessor.componentType == TINYGLTF_COMPONENT_TYPE_SHORT) {
                    const uint16_t* indices_16 = static_cast<const uint16_t*>(indicesPointer);
                    convertedIndices.reserve(indicesAccessor.count);
                    for (size_t i = 0; i < indicesAccessor.count; i++) {
                        convertedIndices.push_back(static_cast<uint32_t>(indices_16[i]));
                    }
                } else if (indicesAccessor.componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT) {
                    const uint16_t* indices_16 = static_cast<const uint16_t*>(indicesPointer);
                    convertedIndices.reserve(indicesAccessor.count);
                    for (size_t i = 0; i < indicesAccessor.count; i++) {
                        convertedIndices.push_back(static_cast<uint32_t>(indices_16[i]));
                    }
                } else if (indicesAccessor.componentType == TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT) {
                    const uint32_t* indices_32 = static_cast<const uint32_t*>(indicesPointer);
                    convertedIndices.assign(indices_32, indices_32 + indicesAccessor.count);
                } else {
                    PLOGE << "Unsupported index component type. Skipping primitive. Index type: " << indicesAccessor.componentType;
                    continue;
                }
 
                // Populate the vertices array
                size_t vertexCount = positionAccessor.count;
                for (size_t i = 0; i < vertexCount; i++) {
                    Vertex vertex{};
                    vertex.position = glm::vec4(getVec3FromMemory(positions, i), 0.0f);
                    vertex.textureCoordinate = getVec2FromMemory(textureCoordinates, i);
                    vertex.normal = glm::vec4(getVec3FromMemory(normals, i), 0.0f);
 
                    vertices.push_back(vertex);
                }
 
                indices.insert(indices.end(), convertedIndices.begin(), convertedIndices.end());
                PLOGD << "Loaded " << indices.size() << " indices";
            }
        }
    }
 
    tinygltf::Model &
    MeshLoaderGltf::getModel(const std::filesystem::path &filePath, tinygltf::Model &model,
                             tinygltf::TinyGLTF &loader) const {
        std::string err;
        std::string warn;
 
        bool loadingSuccess = false;
        if (filePath.has_extension() && filePath.extension().generic_string() == ".glb" ) {
            PLOGD << "Loading a .glb file from " << filePath.generic_string();
            loadingSuccess = loader.LoadBinaryFromFile(&model, &err, &warn, filePath.generic_string());
        } else if (filePath.has_extension() && filePath.extension().generic_string() == "gltf" ) {
            PLOGD << "Loading a .gltf file from " << filePath.generic_string();
            loadingSuccess = loader.LoadASCIIFromFile(&model, &err, &warn, filePath.generic_string());
        }
 
        if (!warn.empty()) {
            PLOGW << "Loading gltf model: " << warn;
            throw std::runtime_error("Warnings while loading a 3d model");
        }
 
        if (!err.empty()) {
            PLOGE << "Error while loading gltf model: " << err;
            throw std::runtime_error("Error while loading mesh");
        }
 
        if (!loadingSuccess) {
            PLOGE << "Failed to load model";
            throw std::runtime_error(std::string("Failed to load model from path: ") + filePath.generic_string());
        }
        return model;
    }
 
    glm::vec3 MeshLoaderGltf::getVec3FromMemory(const float *memory, size_t accessIndex, const bool invert_x, const bool invert_y, const bool invert_z) {
        assert(memory != nullptr);
        return glm::vec3((invert_x ? -1 : 1) * memory[accessIndex * 3 + 0],
            (invert_y ? -1 : 1) * memory[accessIndex * 3 + 1],
            (invert_z ? -1 : 1) * memory[accessIndex * 3 + 2]);
    }
 
    glm::vec2 MeshLoaderGltf::getVec2FromMemory(const float *memory, size_t accessIndex) {
        assert(memory != nullptr);
        return glm::vec2(memory[accessIndex * 2 + 0], memory[accessIndex * 2 + 1]);
    }
}