Method ClearAsyncModelData_

Source/Engine/StratusResourceManager.cpp:97–192

    }

    void ResourceManager::ClearAsyncModelData_() {
        static constexpr size_t maxModelBytesPerFrame = 1024 * 1024 * 2;
        // First generate GPU data for some of the meshes
        size_t totalBytes = 0;
        std::vector<MeshPtr> removeFromGpuDataQueue;
        for (auto mesh : generateMeshGpuDataQueue_) {
            mesh->FinalizeData();
            totalBytes += mesh->GetGpuSizeBytes();
            removeFromGpuDataQueue.push_back(mesh);
            if (removeFromGpuDataQueue.size() > 5 || totalBytes >= maxModelBytesPerFrame) break;
            //if (totalBytes >= maxModelBytesPerFrame) break;
        }

        for (auto mesh : removeFromGpuDataQueue) generateMeshGpuDataQueue_.erase(mesh);

        if (totalBytes > 0) STRATUS_LOG << "Processed " << totalBytes << " bytes of mesh data: " << removeFromGpuDataQueue.size() << " meshes" << std::endl;

        // If none other left to finalize, end early
        if (pendingFinalize_.size() == 0) return;

        //constexpr size_t maxBytes = 1024 * 1024 * 10; // 10 mb per frame
        std::vector<std::string> toDelete;
        for (auto& mpair : pendingFinalize_) {
            if (mpair.second.Completed() && !mpair.second.Failed()) {
                toDelete.push_back(mpair.first);
                auto ptr = mpair.second.GetPtr();

                ClearAsyncModelData_(ptr);
           }
        }

        for (const std::string& name : toDelete) {
           pendingFinalize_.erase(name);
        }

        if (meshFinalizeQueue_.size() == 0) return;

        //size_t totalBytes = 0;
        std::vector<MeshPtr> meshesToDelete(meshFinalizeQueue_.size());
        size_t idx = 0;
        for (auto& mesh : meshFinalizeQueue_) {
            meshesToDelete[idx] = mesh;
            ++idx;
        }

        meshFinalizeQueue_.clear();

        // for (MeshPtr mesh : _meshFinalizeQueue) {
        //     mesh->FinalizeData();
        //     totalBytes += mesh->GetGpuSizeBytes();
        //     meshesToDelete.push_back(mesh);
        //     //if (totalBytes >= maxBytes) break;
        // }

        std::vector<Async<bool>> waiting;
        const size_t numThreads = INSTANCE(TaskSystem)->Size();
        for (size_t i = 0; i < numThreads; ++i) {
            const size_t threadIndex = i;