ResourceManager.h

Ir a la documentación de este archivo.

 
#pragma once
#include "Prerequisites.h"
#include "IResource.h"
 
class 
ResourceManager {
public:
  ResourceManager()  = default;
  ~ResourceManager() = default;
 
  // Singleton
  static ResourceManager& getInstance() {
    static ResourceManager instance;
    return instance;
  }
 
  ResourceManager(const ResourceManager&) = delete;
  ResourceManager& operator=(const ResourceManager&) = delete;
 
  template<typename T, typename... Args>
  std::shared_ptr<T> GetOrLoad(const std::string& key,
                               const std::string& filename,
                               Args&&... args) {
    static_assert(std::is_base_of<IResource, T>::value,
                      "T debe heredar de IResource");
    // 1. ¿Ya existe el recurso en el caché?
    auto it = m_resources.find(key);
    if (it != m_resources.end()) {
      // Intentar castear al tipo correcto
      auto existing = std::dynamic_pointer_cast<T>(it->second);
      if (existing && existing->GetState() == ResourceState::Loaded) {
        return existing; // Flyweight: reutilizamos la instancia
      }
    }
 
    // 2. No existe o no está cargado -> crearlo y cargarlo
    std::shared_ptr<T> resource = std::make_shared<T>(key, std::forward<Args>(args)...);
 
    if (!resource->load(filename)) {
      // Puedes manejar errores más fino aquí
      return nullptr;
    }
 
    if (!resource->init()) {
      return nullptr;
    }
 
    // 3. Guardar en el caché y devolver
    m_resources[key] = resource;
    return resource;
  }
 
  template<typename T>
  std::shared_ptr<T> Get(const std::string& key) const
  {
    auto it = m_resources.find(key);
    if (it == m_resources.end()) return nullptr;
 
    return std::dynamic_pointer_cast<T>(it->second);
  }
 
  void Unload(const std::string& key)
  {
    auto it = m_resources.find(key);
    if (it != m_resources.end()) {
      it->second->unload();
      m_resources.erase(it);
    }
  }
 
  void UnloadAll()
  {
    for (auto& [key, res] : m_resources) {
      if (res) {
        res->unload();
      }
    }
    m_resources.clear();
  }
 
private:
  std::unordered_map<std::string, std::shared_ptr<IResource>> m_resources;
};