Function asyncFromAnySupportedFormat

source/MRMesh/MRSceneLoad.cpp:229–289

}

void asyncFromAnySupportedFormat( const std::vector<std::filesystem::path>& files,
                                  const SceneLoad::PostLoadCallback& postLoadCallback, const Settings& settings )
{
    auto ctx = std::make_shared<AsyncLoadContext>();
    ctx->paths = files;
    std::erase_if( ctx->paths, [] ( auto&& path ) { return path.empty(); } );

    const auto count = ctx->paths.size();
    ctx->results.resize( count, unexpected( "Uninitialized" ) );

    size_t syncIndex = 0;
    BitSet asyncBitSet( count );
    for ( auto index = 0ull; index < count; ++index )
    {
        const auto& path = ctx->paths[index];
        if ( findAsyncObjectLoadFilter( path ) )
        {
            asyncBitSet.set( index );
        }
        else
        {
            spdlog::info( "Loading file {}", utf8string( path ) );
            ctx->results[index] = sLoadPath( path, settings.openFolder, subprogress( settings.progress, syncIndex++, count ) );
        }
    }
    assert( syncIndex + asyncBitSet.count() == count );

    ctx->progressCallback = subprogress( settings.progress, (float)syncIndex / (float)count, 1.00f );
    ctx->initializeProgressMap( asyncBitSet );

    auto postLoad = [ctx, count, postLoadCallback, targetUnit = settings.targetUnit]
    {
        SceneConstructor constructor( targetUnit );
        for ( auto index = 0ull; index < count; ++index )
            constructor.process( ctx->paths[index], ctx->results[index] );
        postLoadCallback( constructor.construct() );
    };

    if ( asyncBitSet.none() )
        return postLoad();

    ctx->asyncCount = asyncBitSet.count();
    for ( const auto index : asyncBitSet )
    {
        const auto& path = ctx->paths[index];
        const auto asyncFilter = findAsyncObjectLoadFilter( path );
        assert( asyncFilter );
        const auto asyncLoader = AsyncObjectLoad::getObjectLoader( *asyncFilter );
        assert( asyncLoader );
        const auto callback = ctx->progressCallbackFor( index );
        spdlog::info( "Async loading file {}", utf8string( path ) );
        asyncLoader( path, [ctx, index, postLoad, callback] ( Expected<LoadedObjects> result )
        {
            ctx->results[index] = std::move( result );
            reportProgress( callback, 1.00f );
            if ( ctx->asyncCount.fetch_sub( 1 ) == 1 )
                // that was the last file
                postLoad();