Method createFromFile

Source/Falcor/Scene/TriangleMesh.cpp:196–274

    }

    ref<TriangleMesh> TriangleMesh::createFromFile(const std::filesystem::path& path, ImportFlags importFlags)
    {
        if (!std::filesystem::exists(path))
        {
            logWarning("Failed to load triangle mesh from '{}': File not found", path);
            return nullptr;
        }

        Assimp::Importer importer;

        unsigned int flags =
            aiProcess_FlipUVs |
            aiProcess_Triangulate |
            aiProcess_PreTransformVertices;
        flags |= is_set(importFlags, ImportFlags::GenSmoothNormals) ? aiProcess_GenSmoothNormals : aiProcess_GenNormals;
        flags |= is_set(importFlags, ImportFlags::JoinIdenticalVertices) ? aiProcess_JoinIdenticalVertices : 0;

        const aiScene* scene = nullptr;

        if (hasExtension(path, "gz"))
        {
            auto decompressed = decompressFile(path);
            scene = importer.ReadFileFromMemory(decompressed.data(), decompressed.size(), flags);
        }
        else
        {
            scene = importer.ReadFile(path.string().c_str(), flags);
        }

        if (!scene)
        {
            logWarning("Failed to load triangle mesh from '{}': {}", path, importer.GetErrorString());
            return nullptr;
        }

        VertexList vertices;
        IndexList indices;

        size_t vertexCount = 0;
        size_t indexCount = 0;

        for (size_t meshIdx = 0; meshIdx < scene->mNumMeshes; ++meshIdx)
        {
            vertexCount += scene->mMeshes[meshIdx]->mNumVertices;
            indexCount += scene->mMeshes[meshIdx]->mNumFaces * 3;
        }

        vertices.reserve(vertexCount);
        indices.reserve(indexCount);

        for (size_t meshIdx = 0; meshIdx < scene->mNumMeshes; ++meshIdx)
        {
            size_t indexBase = vertices.size();
            auto mesh = scene->mMeshes[meshIdx];
            for (size_t vertexIdx = 0; vertexIdx < mesh->mNumVertices; ++vertexIdx)
            {
                const auto& vertex = mesh->mVertices[vertexIdx];
                const auto& normal = mesh->mNormals[vertexIdx];