snake/game/AssetManager.cxx

#include "AssetManager.hxx"

#include <cassert>
#include <filesystem>
#include <format>

#include <SDL_image.h>

AssetManager* AssetManager::instance_ = nullptr;

AssetManager::AssetManager(SDLRenderer& renderer)
    :renderer_{renderer}
{
  namespace fs = std::filesystem;

  assert(instance_==nullptr);

  auto const current_path = fs::current_path();
  auto const asset_directory =
      fs::exists(current_path/"assets")
      ? current_path/"assets"
      : fs::exists(current_path.parent_path()/"assets")
        ? current_path.parent_path()/"assets"
        : fs::path{};
  if (asset_directory.empty()) {
    throw std::runtime_error("Assets directory not found.");
  }

  total_assets_ = std::distance(fs::directory_iterator(asset_directory),
      fs::directory_iterator());

  loading_thread_ = std::thread{&AssetManager::load_assets, this, asset_directory};
  instance_ = this;
}

AssetManager::~AssetManager()
{
  assert(instance_!=nullptr);
  if (loading_thread_.joinable()) {
    loading_thread_.join();
  }
  for (auto const& kv: surface_assets_) {
    SDL_FreeSurface(kv.second);
  }
  for (auto const& kv: texture_assets_) {
    SDL_DestroyTexture(kv.second);
    SDL_Log("Unloaded texture %s successfully.", kv.first.c_str());
  }
  for (auto const& kv: font_assets_) {
    TTF_CloseFont(kv.second);
    SDL_Log("Unloaded font %s successfully.", kv.first.c_str());
  }
  instance_ = nullptr;
}

void AssetManager::load_assets(std::filesystem::path const& asset_directory)
{
  for (auto const& entry: std::filesystem::directory_iterator(asset_directory)) {
    auto const path = entry.path().string();
    auto const ext = entry.path().extension();
    auto const filename = entry.path().filename().string();
    if (ext==".png" || ext==".jpg") {
      auto const surface = IMG_Load(path.c_str());
      if (surface==nullptr) {
        throw SDLError{std::format("Failed to load texture {}.", path)};
      }
      surface_assets_[filename] = surface;
      SDL_Log("Loaded texture %s successfully.", filename.c_str());
    }
    else if (ext==".ttf") {
      auto const font = TTF_OpenFont(path.c_str(), 42);
      if (font==nullptr) {
        throw SDLError{std::format("Failed to load font {}.", path)};
      }
      font_assets_[filename] = font;
      SDL_Log("Loaded font %s successfully.", filename.c_str());
    }
    ++assets_loaded_;
  }
}

float AssetManager::get_progress() const
{
  return static_cast<float>(assets_loaded_)/static_cast<float>(total_assets_);
}

SDL_Texture* AssetManager::get_texture_asset(std::string const& filepath)
{
  auto const it = texture_assets_.find(filepath);
  if (it==std::end(texture_assets_)) {
    auto const surf_it = surface_assets_.find(filepath);
    if (surf_it==std::end(surface_assets_))
      return nullptr;

    auto const texture = SDL_CreateTextureFromSurface(renderer_, surf_it->second);
    texture_assets_[filepath] = texture;
    SDL_FreeSurface(surf_it->second);
    surface_assets_.erase(surf_it);

    return texture;
  }
  return it->second;
}

TTF_Font* AssetManager::get_font_asset(std::string const& filepath)
{
  return font_assets_[filepath];
}

AssetManager& AssetManager::instance() noexcept
{
  assert(instance_!=nullptr);
  return *instance_;
}