Function LoadVirtualFilesFromZip

source/dllmain.cpp:3906–3963

    #endif

    void LoadVirtualFilesFromZip()
    {
        for (const auto& activeDir : sActiveDirectories)
        {
            for (const auto& entry : sFileLoaderEntries)
            {
                if (entry.path == activeDir && entry.isFromZip)
                {
                    for (const auto& archive : entry.archives)
                    {
                        mz_zip_archive zip_archive = {};
                        bool reader_initialized = false;

                        if (archive->is_multi_part)
                        {
                            zip_archive.m_pRead = multipart_zip_read_func;
                            zip_archive.m_pIO_opaque = archive.get();
                            reader_initialized = mz_zip_reader_init(&zip_archive, archive->total_size, 0);
                        }
                        else
                        {
                            reader_initialized = mz_zip_reader_init_file(&zip_archive, archive->parts[0].string().c_str(), 0);
                        }

                        if (reader_initialized)
                        {
                            for (uint32_t i = 0; i < mz_zip_reader_get_num_files(&zip_archive); i++)
                            {
                                mz_zip_archive_file_stat file_stat;
                                if (mz_zip_reader_file_stat(&zip_archive, i, &file_stat) && !mz_zip_reader_is_file_a_directory(&zip_archive, i))
                                {
                                    std::filesystem::path internalPath(file_stat.m_filename);
                                    if (!internalPath.has_root_path() && internalPath.begin() != internalPath.end() && *internalPath.begin() == activeDir)
                                    {
                                        auto virtualPath = lexicallyRelativeCaseIns(internalPath, activeDir);
                                        auto normalizedPath = NormalizePath(virtualPath);
                                        std::unique_lock lock(virtualFilesMutex);
                                        auto it = virtualFilesByPath.find(normalizedPath);
                                        int newPri = entry.priority - 1000;
                                        if (it == virtualFilesByPath.end() || it->second->priority < newPri)
                                        {
                                            auto virtualFile = std::make_shared<VirtualFile>(archive, i, file_stat.m_uncomp_size, newPri);
                                            virtualFilesByPath[normalizedPath] = virtualFile;
                                            if (it == virtualFilesByPath.end())
                                            {
                                                virtualFilesCount.fetch_add(1, std::memory_order_release);
                                            }
                                        }
                                    }
                                }
                            }
                            mz_zip_reader_end(&zip_archive);
                        }
                    }
                }
            }
        }
    }