ResourceManager.hpp

#pragma once
 
#include <SDL3/SDL.h>
#include <SDL3/SDL_log.h>
#include <SDL3_image/SDL_image.h>
#include <SDL3_ttf/SDL_ttf.h>
#include <cstddef>
#include <memory>
#include <string>
#include <unordered_map>
 
#include "Renderer.hpp"
 
struct DeleteTextureFunctor {
  void operator()(SDL_Texture *texture) const { SDL_DestroyTexture(texture); }
};
 
struct DeleteFontFunctor {
  void operator()(TTF_Font *font) const { TTF_CloseFont(font); }
};
 
inline std::shared_ptr<SDL_Texture> make_shared_texture(SDL_Surface *pixels) {
  auto renderer = Renderer::instance();
  SDL_Texture *texture = renderer->CreateTextureFromSurface(pixels);
  if (texture == NULL) {
    SDL_Log("Could not load texture from surface!");
  }
  return std::shared_ptr<SDL_Texture>(texture, DeleteTextureFunctor());
}
 
struct ResourceManager {
 
  static ResourceManager &instance() {
    if (mInstance == nullptr) {
      mInstance = new ResourceManager;
    }
 
    return *mInstance;
  }
 
  std::shared_ptr<SDL_Texture> LoadTexture(std::string filepath) {
    // c++20 -> has contains method. otherwise, use find, cmp with map.end()
    if (!mTextureResources.contains(filepath)) {
      SDL_Surface *surface = IMG_Load(filepath.c_str());
      if (surface == NULL) {
        SDL_LogError(
            SDL_LOG_CATEGORY_APPLICATION,
            "Failed to load texture at path: %s. Maybe the path is wrong?",
            filepath.c_str());
        return NULL;
      }
      SDL_SetSurfaceColorKey(surface, SDL_TRUE,
                             SDL_MapRGB(surface->format, 255, 0, 255));
      auto texture = make_shared_texture(surface);
 
      // c++20 idiom, does insertion in one step vs index assignment.
      mTextureResources.insert({filepath, texture});
 
      SDL_DestroySurface(surface);
      SDL_Log("Created new resource: %s", filepath.c_str());
    } else {
      SDL_Log("Reused resource: %s", filepath.c_str());
    }
    return mTextureResources[filepath];
  }
 
  std::shared_ptr<TTF_Font> LoadFont(std::string filepath, int ptsize) {
    if (!mFontResources.contains(filepath) ||
        !mFontResources[filepath].contains(ptsize)) {
      TTF_Font *font = TTF_OpenFont(filepath.c_str(), ptsize);
      if (font == NULL) {
        SDL_LogError(
            SDL_LOG_CATEGORY_APPLICATION,
            "Failed to load font at path: %s. Maybe the path is wrong?",
            filepath.c_str());
        return nullptr;
      } else {
        SDL_Log("Successfully loaded font at path: %s.", filepath.c_str());
        mFontResources[filepath][ptsize] =
            std::shared_ptr<TTF_Font>(font, DeleteFontFunctor());
      }
    }
 
    return mFontResources[filepath][ptsize];
  }
 
private:
  ResourceManager() {}
 
  static ResourceManager *mInstance;
  std::unordered_map<std::string, std::shared_ptr<SDL_Texture>>
      mTextureResources;
  std::unordered_map<std::string,
                     std::unordered_map<int, std::shared_ptr<TTF_Font>>>
      mFontResources;
};