PakLump.cpp

Go to the documentation of this file.

#include <bsppp/PakLump.h>
 
#include <filesystem>
 
#include <bsppp/BSP.h>
#include <FileStream.h>
#include <mz.h>
#include <mz_zip.h>
#include <sourcepp/FS.h>
#include <sourcepp/String.h>
 
using namespace bsppp;
using namespace sourcepp;
using namespace vpkpp;
 
PakLump::PakLump(const std::string& fullFilePath_)
        : ZIP(fullFilePath_)
        , tempPakLumpPath((std::filesystem::temp_directory_path() / (string::generateUUIDv4() + ".zip")).string()) {}
 
PakLump::~PakLump() {
    // Pull this in from the ZIP dtor, have to do it before deleting the file
    this->closeZIP();
    std::filesystem::remove(this->tempPakLumpPath);
}
 
std::unique_ptr<PackFile> PakLump::open(const std::string& path, const EntryCallback& callback) {
    if (!std::filesystem::exists(path)) {
        // File does not exist
        return nullptr;
    }
 
    auto* bsp = new PakLump{path};
    auto packFile = std::unique_ptr<PackFile>(bsp);
 
    {
        bsppp::BSP reader{path};
        if (!reader) {
            // File failed to load, or has an invalid signature
            return nullptr;
        }
 
        bsp->version = reader.getVersion();
        bsp->mapRevision = reader.getMapRevision();
 
        if (auto pakFileLump = reader.getLumpData(BSPLump::PAKFILE)) {
            // Extract the paklump to a temp file
            FileStream writer{bsp->tempPakLumpPath, FileStream::OPT_TRUNCATE | FileStream::OPT_CREATE_IF_NONEXISTENT};
            writer.write(*pakFileLump);
        } else {
            // No paklump, create an empty zip
            if (!ZIP::create(bsp->tempPakLumpPath)) {
                return nullptr;
            }
        }
    }
 
    if (!bsp->openZIP(bsp->tempPakLumpPath)) {
        return nullptr;
    }
 
    for (auto code = mz_zip_goto_first_entry(bsp->zipHandle); code == MZ_OK; code = mz_zip_goto_next_entry(bsp->zipHandle)) {
        mz_zip_file* fileInfo = nullptr;
        if (mz_zip_entry_get_info(bsp->zipHandle, &fileInfo)) {
            return nullptr;
        }
        if (mz_zip_entry_is_dir(bsp->zipHandle) == MZ_OK) {
            continue;
        }
 
        auto entryPath = bsp->cleanEntryPath(fileInfo->filename);
 
        Entry entry = createNewEntry();
        entry.flags = fileInfo->compression_method << 16;
        entry.length = fileInfo->uncompressed_size;
        entry.compressedLength = fileInfo->compressed_size;
        entry.crc32 = fileInfo->crc;
 
        bsp->entries.emplace(entryPath, entry);
 
        if (callback) {
            callback(entryPath, entry);
        }
    }
 
    return packFile;
}
 
bool PakLump::bake(const std::string& outputDir_, BakeOptions options, const EntryCallback& callback) {
    // Get the proper file output folder
    const std::string outputDir = this->getBakeOutputDir(outputDir_);
    const std::string outputPath = outputDir + '/' + this->getFilename();
 
    // If the output path is different, copy the entire BSP there
    if (outputPath != this->fullFilePath) {
        std::filesystem::copy_file(this->fullFilePath, outputPath, std::filesystem::copy_options::overwrite_existing);
        PackFile::setFullFilePath(outputDir);
    }
 
    // Use temp folder so we can read from the current ZIP
    if (!this->bakeTempZip(this->tempZIPPath, options, callback)) {
        return false;
    }
    this->mergeUnbakedEntries();
 
    // Close the ZIP
    this->closeZIP();
 
    // Write the new lump
    {
        bsppp::BSP writer{this->fullFilePath};
        if (!writer) {
            return false;
        }
        writer.setLump(BSPLump::PAKFILE, 0, fs::readFileBuffer(this->tempZIPPath));
        writer.bake();
    }
 
    // Rename and reopen the ZIP
    std::filesystem::rename(this->tempZIPPath, this->tempPakLumpPath);
    return this->openZIP(this->tempPakLumpPath);
}
 
PakLump::operator std::string() const {
    return PackFile::operator std::string() +
           " | Version v" + std::to_string(this->version) +
           " | Map Revision " + std::to_string(this->mapRevision);
}