Method startAsyncExport

src/visualizer/gui/async_task_manager.cpp:911–1188

    }

    void AsyncTaskManager::startAsyncExport(ExportFormat format,
                                            const std::filesystem::path& path,
                                            std::vector<ExportSplatSource> splats,
                                            int sh_degree,
                                            bool borrow_single_identity,
                                            std::shared_mutex* model_mutex,
                                            bool rad_flip_y,
                                            bool rad_streamable) {
        if (splats.empty()) {
            LOG_ERROR("No splat data to export");
            publishExportFailureState(format, path, "No splat data to export");
            return;
        }

        export_state_.active.store(true);
        export_state_.cancel_requested.store(false);
        export_state_.progress.store(0.0f);
        {
            const std::lock_guard lock(export_state_.mutex);
            export_state_.format = format;
            export_state_.stage = "Starting";
            export_state_.error.clear();
            export_state_.path = path;
        }
        publishExportState();

        LOG_INFO("Export started: {} (format: {})", lfs::core::path_to_utf8(path), static_cast<int>(format));

        export_state_.thread.emplace(
            [this,
             format,
             path,
             splats = std::move(splats),
             sh_degree,
             borrow_single_identity,
             model_mutex,
             rad_flip_y,
             rad_streamable](
                std::stop_token stop_token) mutable {
                bool cancellation_logged = false;
                auto update_progress = [this, &stop_token, &cancellation_logged](float progress, const std::string& stage) -> bool {
                    if (stop_token.stop_requested() || export_state_.cancel_requested.load()) {
                        if (!cancellation_logged) {
                            LOG_INFO("Export cancelled");
                            cancellation_logged = true;
                        }
                        {
                            const std::lock_guard lock(export_state_.mutex);
                            export_state_.stage = "Cancelled";
                        }
                        publishExportState();
                        if (auto* window_manager = services().windowOrNull()) {
                            window_manager->wakeEventLoop();
                        }
                        return false;
                    }
                    export_state_.progress.store(progress);
                    {