ModelLoader.cpp

Go to the documentation of this file.

#include "hellfire/assets/ModelLoader.h"
#include <filesystem>
#include <fstream>
#include <iostream>
#include <glm/gtc/quaternion.hpp>
#include <glm/gtx/matrix_decompose.hpp>
 
#include "assimp/Importer.hpp"
#include "hellfire/ecs/RenderableComponent.h"
#include "../ecs/Entity.h"
#include "hellfire/ecs/TransformComponent.h"
#include "hellfire/ecs/components/MeshComponent.h"
#include "hellfire/scene/Scene.h"
 
namespace fs = std::filesystem;
 
#define MODEL_LOADER_DEBUG 0
 
namespace hellfire::Addons {
    // Static member definitions
    std::unordered_map<std::string, std::shared_ptr<Mesh> > ModelLoader::mesh_cache;
    std::unordered_map<std::string, std::shared_ptr<Material> > ModelLoader::material_cache;
    std::unordered_map<std::string, std::shared_ptr<Texture> > ModelLoader::texture_cache;
 
    EntityID ModelLoader::load_model(Scene *scene, const std::filesystem::path &filepath, unsigned int import_flags) {
        const auto start_time = std::chrono::high_resolution_clock::now();
        std::cout << "Loading model: " << filepath << std::endl;
 
        Assimp::Importer importer;
 
        // Use provided flags or default to runtime
        if (import_flags == 0) {
            import_flags = ImportFlags::HIGH_QUALITY;
        }
 
        // Parse model file
        const aiScene *ai_scene = importer.ReadFile(filepath.string(), import_flags);
 
        if (!ai_scene || ai_scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE || !ai_scene->mRootNode) {
            std::cerr << "ModelLoader: Cannot load " << filepath << " - "
                    << importer.GetErrorString() << std::endl;
            return 0;
        }
 
        // Debug information
#if MODEL_LOADER_DEBUG
        debug_scene_info(ai_scene, filepath.string());
#endif
 
        // Pre-process materials for caching
        preprocess_materials(ai_scene, filepath.string());
 
        // Process the scene
        const EntityID imported_model = process_node(scene, ai_scene->mRootNode, ai_scene, filepath.string());
        scene->update_world_matrices();
 
        const auto end_time = std::chrono::high_resolution_clock::now();
        const auto duration = std::chrono::duration_cast<std::chrono::milliseconds>(end_time - start_time);
        std::cout << "Model loaded in: " << duration.count() << "ms" << std::endl;
 
        return imported_model;
    }
 
    void ModelLoader::debug_scene_info(const aiScene *scene, const std::string &filepath) {
        std::cout << "=== Scene Debug Info for " << fs::path(filepath).filename() << " ===" << std::endl;
        std::cout << "Size: " << fs::file_size(filepath) / 1024 << "(KB)" << std::endl;
        std::cout << "Materials: " << scene->mNumMaterials << std::endl;
        std::cout << "Meshes: " << scene->mNumMeshes << std::endl;
        std::cout << "Embedded Textures: " << scene->mNumTextures << std::endl;
 
        // Print embedded texture info
        for (unsigned int i = 0; i < scene->mNumTextures; i++) {
            const aiTexture *tex = scene->mTextures[i];
            std::cout << "  Embedded texture " << i << ": "
                    << tex->mWidth << "x" << tex->mHeight
                    << " format: " << tex->achFormatHint << std::endl;
        }
 
        std::cout << "=============================================" << std::endl;
    }
 
    void ModelLoader::preprocess_materials(const aiScene *scene, const std::string &filepath) {
#if MODEL_LOADER_DEBUG
        std::cout << "Preprocessing " << scene->mNumMaterials << " materials..." << std::endl;
#endif
 
        for (unsigned int i = 0; i < scene->mNumMaterials; i++) {
            const aiMaterial *ai_material = scene->mMaterials[i];
 
            // Create material cache key
            std::string cache_key = create_material_key(ai_material, filepath, i);
 
            // Skip if already cached
            if (material_cache.find(cache_key) != material_cache.end()) {
                continue;
            }
 
            // Create and cache material
            const auto material = create_material(ai_material, scene, filepath);
            material_cache[cache_key] = material;
        }
    }
 
    // This method converts assimp matrix struct to glm matrix struct
    glm::mat4 aiMatrix4x4ToGlm(const aiMatrix4x4 &from) {
        glm::mat4 to;
        to[0][0] = from.a1;
        to[1][0] = from.a2;
        to[2][0] = from.a3;
        to[3][0] = from.a4;
        to[0][1] = from.b1;
        to[1][1] = from.b2;
        to[2][1] = from.b3;
        to[3][1] = from.b4;
        to[0][2] = from.c1;
        to[1][2] = from.c2;
        to[2][2] = from.c3;
        to[3][2] = from.c4;
        to[0][3] = from.d1;
        to[1][3] = from.d2;
        to[2][3] = from.d3;
        to[3][3] = from.d4;
        return to;
    }
 
    EntityID ModelLoader::process_node(Scene *scene, aiNode *node, const aiScene *ai_scene, const std::string &filepath,
                                       EntityID parent_id) {
        bool should_create_entity = node->mNumMeshes > 0 ||
                                    node->mNumChildren > 0 ||
                                    !is_identity_transform(node->mTransformation);
 
        EntityID entity_id = 0;
        Entity *entity = nullptr;
 
        if (should_create_entity) {
            std::string node_name = node->mName.length > 0
                                        ? node->mName.C_Str()
                                        : ("Node_" + std::to_string(reinterpret_cast<uintptr_t>(node)));
 
            entity_id = scene->create_entity(node_name);
            entity = scene->get_entity(entity_id);
 
            // Apply transform
            glm::mat4 transform = aiMatrix4x4ToGlm(node->mTransformation);
            glm::vec3 translation, scale, skew;
            glm::quat rotation;
            glm::vec4 perspective;
            glm::decompose(transform, scale, rotation, translation, skew, perspective);
 
            entity->transform()->set_position(translation);
            entity->transform()->set_scale(scale);
            entity->transform()->set_rotation(rotation);
 
            if (parent_id != 0) {
                scene->set_parent(entity_id, parent_id);
            }
        }
 
        // Process meshes
        if (entity_id != 0) {
            for (unsigned int i = 0; i < node->mNumMeshes; i++) {
                unsigned int mesh_index = node->mMeshes[i];
                aiMesh *ai_mesh = ai_scene->mMeshes[mesh_index];
 
                std::shared_ptr<Mesh> processed_mesh = process_mesh(ai_mesh, ai_scene, filepath);
 
                // Get material
                std::shared_ptr<Material> material = nullptr;
                if (ai_mesh->mMaterialIndex >= 0) {
                    const aiMaterial *ai_material = ai_scene->mMaterials[ai_mesh->mMaterialIndex];
                    std::string material_key = create_material_key(ai_material, filepath, ai_mesh->mMaterialIndex);
 
                    auto cached_material = material_cache.find(material_key);
                    if (cached_material != material_cache.end()) {
                        material = cached_material->second;
                    } else {
                        material = create_material(ai_material, ai_scene, filepath);
                        material_cache[material_key] = material;
                    }
                }
 
                // Determine where to attach mesh components
                EntityID mesh_entity_id;
                Entity *mesh_entity;
 
                if (node->mNumMeshes == 1) {
                    // Single mesh: attach to current node
                    mesh_entity_id = entity_id;
                    mesh_entity = entity;
                } else {
                    // Multiple meshes: create submesh entity
                    std::string mesh_name = ai_mesh->mName.length > 0
                                                ? ai_mesh->mName.C_Str()
                                                : (std::string(node->mName.C_Str()) + "_Mesh_" + std::to_string(i));
 
                    mesh_entity_id = scene->create_entity(mesh_name);
                    mesh_entity = scene->get_entity(mesh_entity_id);
                    scene->set_parent(mesh_entity_id, entity_id);
                }
 
                // Add mesh and material components
                auto *mesh_comp = mesh_entity->add_component<MeshComponent>();
                mesh_comp->set_mesh(processed_mesh);
 
                auto *renderable = mesh_entity->add_component<RenderableComponent>();
                if (material) {
                    renderable->set_material(material);
                }
            }
        }
 
        // Process children recursively
        for (unsigned int i = 0; i < node->mNumChildren; i++) {
            process_node(scene, node->mChildren[i], ai_scene, filepath,
                         entity_id != 0 ? entity_id : parent_id);
        }
 
        return entity_id;
    }
 
    bool ModelLoader::is_identity_transform(const aiMatrix4x4 &matrix) {
        const float epsilon = 0.0001f;
        return std::abs(matrix.a1 - 1.0f) < epsilon && std::abs(matrix.b2 - 1.0f) < epsilon &&
               std::abs(matrix.c3 - 1.0f) < epsilon && std::abs(matrix.d4 - 1.0f) < epsilon &&
               std::abs(matrix.a2) < epsilon && std::abs(matrix.a3) < epsilon && std::abs(matrix.a4) < epsilon &&
               std::abs(matrix.b1) < epsilon && std::abs(matrix.b3) < epsilon && std::abs(matrix.b4) < epsilon &&
               std::abs(matrix.c1) < epsilon && std::abs(matrix.c2) < epsilon && std::abs(matrix.c4) < epsilon &&
               std::abs(matrix.d1) < epsilon && std::abs(matrix.d2) < epsilon && std::abs(matrix.d3) < epsilon;
    }
 
    void ModelLoader::process_mesh_vertices(aiMesh *mesh, std::vector<Vertex> &vertices,
                                            std::vector<unsigned int> &indices) {
        vertices.reserve(mesh->mNumVertices);
        indices.reserve(mesh->mNumFaces * 3);
 
        for (unsigned int i = 0; i < mesh->mNumVertices; i++) {
            Vertex &v = vertices.emplace_back();
            // Position
            const auto &pos = mesh->mVertices[i];
            v.position = glm::vec3(pos.x, pos.y, pos.z);
 
            // Normal
            if (mesh->HasNormals()) {
                const auto &norm = mesh->mNormals[i];
                v.normal = glm::vec3(norm.x, norm.y, norm.z);
            } else {
                v.normal = glm::vec3(0.0f, 1.0f, 0.0f); // Default up
            }
 
            if (mesh->HasTangentsAndBitangents()) {
                const auto &bitan = mesh->mBitangents[i];
                const auto &tan = mesh->mTangents[i];
                v.tangent = glm::vec3(tan.x, tan.y, tan.z);
                v.bitangent = glm::vec3(bitan.x, bitan.y, bitan.z);
            } else {
                v.tangent = glm::vec3(1.0f, 0.0f, 0.0f);
                v.bitangent = glm::vec3(0.0f, 1.0f, 0.0f);
            }
 
            // Color
            if (mesh->HasVertexColors(0)) {
                const auto &col = mesh->mColors[0][i];
                v.color = glm::vec3(col.r, col.g, col.b);
            } else {
                v.color = glm::vec3(1.0f); // Default white
            }
 
            // Texture coordinates
            if (mesh->HasTextureCoords(0)) {
                const auto &tex = mesh->mTextureCoords[0][i];
                v.texCoords = glm::vec2(tex.x, tex.y);
            } else {
                v.texCoords = glm::vec2(0.0f);
            }
        }
 
        for (unsigned int i = 0; i < mesh->mNumFaces; i++) {
            const aiFace &face = mesh->mFaces[i];
            for (unsigned int j = 0; j < face.mNumIndices; j++) {
                indices.push_back(face.mIndices[j]);
            }
        }
    }
 
    std::string ModelLoader::create_mesh_key(aiMesh *mesh, const std::string &filepath) {
        return filepath + "_mesh_" + std::string(mesh->mName.C_Str()) + "_" + std::to_string(mesh->mMaterialIndex);
    }
 
    std::string ModelLoader::create_material_key(const aiMaterial *ai_material, const std::string &filepath,
                                                 unsigned int material_index) {
        aiString material_name;
        ai_material->Get(AI_MATKEY_NAME, material_name);
        return filepath + "_mat_" + std::to_string(material_index) + "_" +
               (material_name.length > 0 ? material_name.C_Str() : "unnamed");
    }
 
    std::shared_ptr<Mesh> ModelLoader::process_mesh(aiMesh *mesh, const aiScene *scene, const std::string &filepath) {
        // Create mesh key and check cache
        const std::string mesh_key = create_mesh_key(mesh, filepath);
        const auto cached = mesh_cache.find(mesh_key);
        if (cached != mesh_cache.end()) {
            std::cout << "Using cached mesh: " << mesh_key << std::endl;
            return cached->second;
        }
 
        std::vector<Vertex> vertices;
        std::vector<unsigned int> indices;
        process_mesh_vertices(mesh, vertices, indices);
 
        // Create mesh WITHOUT material
        auto processed_mesh = std::make_shared<Mesh>(vertices, indices);
 
        // Cache the mesh
        mesh_cache[mesh_key] = processed_mesh;
 
        return processed_mesh;
    }
 
 
    std::shared_ptr<Material> ModelLoader::create_material(const aiMaterial *ai_material, const aiScene *scene,
                                                           const std::string &filepath
    ) {
        // Get material name
        aiString material_name;
        ai_material->Get(AI_MATKEY_NAME, material_name);
        const std::string name = material_name.length > 0 ? material_name.C_Str() : "ImportedMaterial";
 
        // Create Lambert Material 
        auto material = MaterialBuilder::create(name);
 
        // Load ALL properties
        load_essential_material_properties(ai_material, *material);
 
        // Load textures
        load_material_textures(ai_material, *material, scene, filepath);
 
        return material;
    }
 
    void ModelLoader::load_essential_material_properties(const aiMaterial *ai_material, Material &material) {
        aiColor3D color;
        float value;
 
        // Load color properties and convert them to the engine's material system
        if (ai_material->Get(AI_MATKEY_COLOR_DIFFUSE, color) == AI_SUCCESS) {
            material.set_diffuse_color(glm::vec3(color.r, color.g, color.b));
        }
 
        if (ai_material->Get(AI_MATKEY_COLOR_AMBIENT, color) == AI_SUCCESS) {
            material.set_ambient_color(glm::vec3(color.r, color.g, color.b));
        }
 
        if (ai_material->Get(AI_MATKEY_COLOR_SPECULAR, color) == AI_SUCCESS) {
            material.set_specular_color(glm::vec3(color.r, color.g, color.b));
        }
 
        if (ai_material->Get(AI_MATKEY_COLOR_EMISSIVE, color) == AI_SUCCESS) {
            material.set_emissive_color(glm::vec3(color.r, color.g, color.b));
        }
 
        // Load scalar properties using constants
        if (ai_material->Get(AI_MATKEY_OPACITY, value) == AI_SUCCESS) {
            material.set_opacity(value);
        }
 
        if (ai_material->Get(AI_MATKEY_SHININESS, value) == AI_SUCCESS) {
            material.set_shininess(std::max(value, 1.0f));
        }
 
        if (ai_material->Get(AI_MATKEY_METALLIC_FACTOR, value) == AI_SUCCESS) {
            material.set_metallic(value);
        }
 
        if (ai_material->Get(AI_MATKEY_ROUGHNESS_FACTOR, value) == AI_SUCCESS) {
            material.set_roughness(value);
        }
    }
 
    std::vector<std::string> ModelLoader::get_texture_search_paths(const std::string &filepath) {
        const std::filesystem::path model_dir = std::filesystem::path(filepath).parent_path();
 
        return {
            model_dir.string() + "/textures/",
            model_dir.string() + "/Textures/",
            model_dir.string() + "/texture/",
            model_dir.string() + "/materials/",
            model_dir.string() + "/source/",
            model_dir.string() + "/../textures/",
            model_dir.string() + "/",
            "assets/models/",
            "assets/textures/"
        };
    }
 
    void ModelLoader::load_material_textures(const aiMaterial *ai_material, Material &material, const aiScene *scene,
                                             const std::string &filepath) {
        auto load_texture = [&](aiTextureType ai_type, TextureType dcr_type) {
            if (ai_material->GetTextureCount(ai_type) == 0) return;
 
            aiString texture_path;
            if (ai_material->GetTexture(ai_type, 0, &texture_path) != AI_SUCCESS) return;
 
            const std::string path_str = texture_path.C_Str();
 
            // Try embedded texture first
            if (try_load_embedded_texture_unified(path_str, scene, dcr_type, material)) {
                return;
            }
 
            // Try external texture
            if (try_load_external_texture_unified(path_str, filepath, dcr_type, material)) {
                return;
            }
 
            std::cerr << "Failed to load texture: " << path_str << std::endl;
        };
 
        // Load textures using the enum-based system
        load_texture(aiTextureType_DIFFUSE, TextureType::DIFFUSE);
        load_texture(aiTextureType_NORMALS, TextureType::NORMAL);
        load_texture(aiTextureType_SPECULAR, TextureType::SPECULAR);
        load_texture(aiTextureType_METALNESS, TextureType::METALNESS);
        load_texture(aiTextureType_DIFFUSE_ROUGHNESS, TextureType::ROUGHNESS);
        load_texture(aiTextureType_AMBIENT_OCCLUSION, TextureType::AMBIENT_OCCLUSION);
        load_texture(aiTextureType_EMISSIVE, TextureType::EMISSIVE);
    }
 
    bool ModelLoader::try_load_embedded_texture_unified(const std::string &path_str,
                                                        const aiScene *scene,
                                                        TextureType type,
                                                        Material &material) {
        if (path_str.empty() || path_str[0] != '*') {
            return false;
        }
 
        try {
            const int texture_index = std::stoi(path_str.substr(1));
 
            if (!scene || texture_index >= static_cast<int>(scene->mNumTextures)) {
                std::cerr << "Embedded texture index " << texture_index << " is out of range!" << std::endl;
                return false;
            }
 
            const aiTexture *embedded_texture = scene->mTextures[texture_index];
 
            // Handle compressed embedded textures
            if (embedded_texture->mHeight == 0) {
                std::string extension = embedded_texture->achFormatHint;
                if (extension.empty() || extension.length() > 4) {
                    const unsigned char *data = reinterpret_cast<const unsigned char *>(embedded_texture->pcData);
                    if (data && embedded_texture->mWidth >= 2) {
                        if (data[0] == 0xFF && data[1] == 0xD8) extension = "jpg";
                        else if (data[0] == 0x89 && data[1] == 0x50) extension = "png";
                        else if (data[0] == 'B' && data[1] == 'M') extension = "bmp";
                        else extension = "bin";
                    } else {
                        extension = "bin";
                    }
                }
 
                const std::string temp_filename = "temp_texture_" + std::to_string(texture_index) + "." + extension;
 
                std::ofstream temp_file(temp_filename, std::ios::binary);
                if (!temp_file) {
                    std::cerr << "Failed to create temp file: " << temp_filename << std::endl;
                    return false;
                }
 
                temp_file.write(reinterpret_cast<const char *>(embedded_texture->pcData), embedded_texture->mWidth);
                temp_file.close();
 
                try {
                    // Use the unified texture setting API
                    material.set_texture(temp_filename, type, 0);
 
 
                    std::filesystem::remove(temp_filename);
                    return true;
                } catch (const std::exception &e) {
                    std::cerr << "Exception loading embedded texture: " << e.what() << std::endl;
                }
 
                std::filesystem::remove(temp_filename);
                return false;
            }
            // Handle uncompressed embedded textures
            else {
                std::cout << "Uncompressed embedded texture found - needs direct GPU upload implementation" <<
                        std::endl;
                return false;
            }
        } catch (const std::exception &e) {
            std::cerr << "Error processing embedded texture: " << e.what() << std::endl;
            return false;
        }
    }
 
    bool ModelLoader::try_load_external_texture_unified(const std::string &path_str,
                                                        const std::string &filepath,
                                                        TextureType type,
                                                        Material &material) {
        const std::string texture_filename = std::filesystem::path(path_str).filename().string();
        const std::filesystem::path model_dir = std::filesystem::path(filepath).parent_path();
 
        const std::vector<std::string> possible_paths = {
            path_str,
            model_dir.string() + "/" + path_str,
            model_dir.string() + "/textures/" + texture_filename,
            model_dir.string() + "/Textures/" + texture_filename,
            model_dir.string() + "/texture/" + texture_filename,
            model_dir.string() + "/materials/" + texture_filename,
            model_dir.string() + "/source/" + texture_filename,
            model_dir.string() + "/../textures/" + texture_filename,
            model_dir.string() + "/" + texture_filename,
            "assets/models/" + texture_filename,
            "assets/textures/" + texture_filename
        };
 
        for (const auto &test_path: possible_paths) {
            if (std::filesystem::exists(test_path)) {
                auto texture = load_cached_texture(test_path, type);
                if (texture) {
                    // Use the unified texture setting API
                    material.set_texture(texture, 0);
                    return true;
                }
            }
        }
        return false;
    }
 
    std::shared_ptr<Texture> ModelLoader::load_cached_texture(const std::string &path, TextureType type) {
        const auto it = texture_cache.find(path);
        if (it != texture_cache.end()) {
            std::cout << "Using cached texture: " << path << std::endl;
            return it->second;
        }
 
        try {
            auto texture = std::make_shared<Texture>(path, type);
            if (texture->is_valid()) {
                texture_cache[path] = texture;
                return texture;
            }
        } catch (const std::exception &e) {
            std::cerr << "Failed to load texture " << path << ": " << e.what() << std::endl;
        }
 
        return nullptr;
    }
 
    std::string ModelLoader::capitalize_first(const std::string &str) {
        if (str.empty()) return str;
        std::string result = str;
        result[0] = std::toupper(result[0]);
        return result;
    }
 
    void ModelLoader::clear_cache() {
        mesh_cache.clear();
        material_cache.clear();
        texture_cache.clear();
        std::cout << "ModelLoader caches cleared" << std::endl;
    }
 
    void ModelLoader::print_cache_stats() {
        std::cout << "=== ModelLoader Cache Statistics ===" << std::endl;
        std::cout << "Cached meshes: " << mesh_cache.size() << std::endl;
        std::cout << "Cached materials: " << material_cache.size() << std::endl;
        std::cout << "====================================" << std::endl;
    }
}