ResourceArchive.cpp

#include "ResourceArchive.h"
#include "Context.h"
#include "Resources/ResourceStore.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/IO.h"
#include "Foundation/Platform/Threads.h"
 
#include <../miniz/miniz.h>
 
#include <unordered_map>
 
namespace
{
  const Cogs::Logging::Log logger = Cogs::Logging::getLogger("ResourceArchive");
}
 
struct Cogs::Core::Archive
{
  mz_zip_archive archive = {};
  // TODO Adding custom hashing to allow string_view lookup - when Linux compiler allows.
  std::unordered_map<std::string, mz_zip_archive_file_stat> entries;
  mutable Mutex m;
};
 
extern "C"
{
  int ResourceArchiveDummy() { return 42; }
}
 
Cogs::Core::ResourceArchive::ResourceArchive(ResourceStore * store, std::string_view archivePath)
  : storage(std::make_unique<Archive>())
{
  std::string archiveName(archivePath);
  std::string fileName = archiveName;
 
#ifndef EMSCRIPTEN
  if (!IO::exists(fileName)) {
    // Couldn't locate the archive in the current working directory, try the directory containing the dll we are running from:
    fileName = IO::getPathRelativeToDll(archiveName, (void *)&ResourceArchiveDummy);
  }
 
  if (!IO::exists(fileName)) {
    // Look in our parent directory.  This is the most likely location during development.
    fileName = IO::combine(IO::parentPath(IO::parentPath(fileName)), IO::fileName(archivePath));
 
    if (!IO::exists(fileName)) {
      // If we could not locate the default resource archive in our current directory, we try once more using
      // the COGSDIR variable.
      auto cogsDir = IO::expandEnvironmentVariable("COGSDIR");
 
      if (cogsDir.size() && (cogsDir != "%COGSDIR%")) {
        fileName = cogsDir + "/bin/" + archiveName;
 
        if (!IO::exists(fileName)) {
          // Revert to lookup in resource system.
          fileName = archiveName;
        }
      }
      else {
        LOG_WARNING(logger, "Could not locate resource file %s, no COGSDIR environment variable found.", fileName.c_str());
      }
    }
  }
#endif
 
  auto contents = store->getResourceContents(fileName);
 
  if (contents.empty()) {
    LOG_ERROR(logger, "File or Resource not found? Empty resource archive. %s", fileName.c_str());
    return;
  }
  mz_uint numEntries = 0;
 
  if (mz_zip_reader_init_mem(&storage->archive, contents.data(), contents.size(), 0)) {
    numEntries = mz_zip_reader_get_num_files(&storage->archive);
    LOG_DEBUG(logger, "Loaded resource file (Entries=%u) %s.", static_cast<uint32_t>(numEntries), fileName.c_str());
  } else {
    LOG_ERROR(logger, "Failed to open archive %s.", fileName.c_str());
  }
 
  if (!numEntries) {
    LOG_WARNING(logger, "Archive %s contains no entries.", fileName.c_str());
  }
 
  for (mz_uint i = 0; i < numEntries; ++i) {
    mz_zip_archive_file_stat entry = {};
    mz_zip_reader_file_stat(&storage->archive, i, &entry);
 
    storage->entries[entry.m_filename] = entry;
  }
}
 
Cogs::Core::ResourceArchive::~ResourceArchive()
{
  if (storage && storage->archive.m_archive_size) {
    if (!mz_zip_reader_end(&storage->archive)) {
      LOG_WARNING(logger, "Failed to release zip archive.");
    }
  }
}
 
Cogs::Core::ResourceArchive::ResourceArchive(ResourceArchive && other)
{
  storage = std::move(other.storage);
}
 
Cogs::Core::ResourceArchive& Cogs::Core::ResourceArchive::operator=(ResourceArchive&& other)
{
  storage = std::move(other.storage);
  return *this;
}
 
 
bool Cogs::Core::ResourceArchive::hasResource(std::string_view path) const
{
  LockGuard lock(storage->m);
 
  auto archiveIt = storage->entries.find(std::string(path));
 
  return archiveIt != storage->entries.end();
}
 
Cogs::Memory::MemoryBuffer Cogs::Core::ResourceArchive::getResource(std::string_view path) const
{
  LockGuard lock(storage->m);
 
  auto archiveIt = storage->entries.find(std::string(path));
  if (archiveIt != storage->entries.end()) {
    const auto& entry = archiveIt->second;
    Cogs::Memory::MemoryBuffer bytes(entry.m_uncomp_size, Cogs::MemBlockType::IOResource);
    mz_zip_reader_extract_to_mem(&storage->archive, entry.m_file_index, bytes.data(), bytes.size(), 0);
    return bytes;
  }
  else {
    LOG_WARNING(logger, "Internal Error: read of non-existing resource. Must check hasResource.");
    Cogs::Memory::MemoryBuffer bytes;
    return bytes;
  }
}