AssetUtils.hpp

Go to the documentation of this file.

#pragma once
 
#include <filesystem>
 
#include <AssetManager/Asset.hpp>
#include <Common/Assert.hpp>
#include <Common/Types.hpp>
#include <Components/AssetComponents/AssetComponent.hpp>
#include <Components/AssetComponents/AssetLoader.hpp>
#include <Components/AssetComponents/DirectoryComponent.hpp>
#include <ECS/Registry.hpp>
#include <Serialization/Builders.hpp>
 
namespace shkyera::utils::assets {
 
template <typename AssetType>
class PathAssetLoader : public AssetLoader<AssetType> {
 public:
  PathAssetLoader(std::filesystem::path path_) : path(std::move(path_)) {}
 
  ~PathAssetLoader() = default;
 
  AssetType operator()() override { return AssetType(path); }
 
  std::filesystem::path path;
};
 
template <typename AssetType>
class FactoryAssetLoader : public AssetLoader<AssetType> {
 public:
  using Factory = typename AssetType::Factory;
 
  FactoryAssetLoader(Factory::Type type_) : type(type_) {}
 
  ~FactoryAssetLoader() = default;
 
  AssetType operator()() override { return Factory::create(type); }
 
  Factory::Type type;
};
 
std::optional<AssetHandle> registerSingle(std::filesystem::path path, Registry* registry);
 
std::optional<AssetHandle> registerAll(std::filesystem::path path, Registry* registry);
 
std::vector<AssetHandle> getSubdirectories(AssetHandle directory, Registry const* registry);
 
template <typename AssetType>
AssetRef<AssetType> read(AssetComponent<AssetType>& assetComponent) {
  if (auto asset = assetComponent.assetPtr.lock()) {
    return asset;
  }
 
  auto asset = std::make_shared<AssetType>((*assetComponent.constructionFunction)());
  assetComponent.assetPtr = asset;
  return asset;
}
 
template <typename AssetType>
AssetRef<AssetType> read(Registry* registry, HandleAndAsset<AssetType>& handleAndAsset) {
  if (const auto assetRef = std::get<AssetRef<AssetType>>(handleAndAsset)) {
    return assetRef;
  }
 
  if (const auto assetHandleOpt = std::get<OptionalAssetHandle>(handleAndAsset)) {
    SHKYERA_ASSERT(registry->hasComponent<AssetComponent<AssetType>>(*assetHandleOpt),
                   "{} does not have an associated Asset Component for {}", *assetHandleOpt, typeid(AssetType).name());
    return read<AssetType>(registry->getComponent<AssetComponent<AssetType>>(*assetHandleOpt));
  }
 
  return nullptr;
}
 
template <typename AssetType, typename... Args>
AssetRef<AssetType> read(const std::filesystem::path& path, Args&&... args) {
  return std::make_shared<AssetType>(path, std::forward<Args>(args)...);
}
 
template <typename AssetType>
AssetRef<AssetType> read(typename AssetType::Factory::Type type) {
  auto component = std::make_shared<AssetType>(AssetType::Factory::create(type));
  return component;
}
 
template <typename AssetType>
HandleAndAsset<AssetType> add(Registry* registry, std::unique_ptr<AssetLoader<AssetType>> loader) {
  auto assetHandle = registry->addEntity();
  auto& assetComponent = registry->addComponent<AssetComponent<AssetType>>(assetHandle, std::move(loader));
  return {assetHandle, read(assetComponent)};
}
 
template <typename AssetType>
HandleAndAsset<AssetType> add(Registry* registry, std::filesystem::path&& path) {
  return add<AssetType>(registry, std::make_unique<PathAssetLoader<AssetType>>(path));
}
 
template <typename AssetType>
HandleAndAsset<AssetType> add(Registry* registry, typename AssetType::Factory::Type type) {
  return add<AssetType>(registry, std::make_unique<FactoryAssetLoader<AssetType>>(type));
}
 
template <typename AssetType, typename... Args>
AssetRef<AssetType> readPermanent(const std::filesystem::path& path, Args&&... args) {
  namespace fs = std::filesystem;
  static std::unordered_map<fs::path, AssetRef<AssetType>, GlobalPathHash, GlobalPathEqual> permanentAssets;
 
  if (!permanentAssets.contains(path)) {
    const auto assetPtr = std::make_shared<AssetType>(path, args...);
    permanentAssets[path] = assetPtr;
    return assetPtr;
  }
 
  return permanentAssets.at(path);
}
 
template <typename AssetType>
AssetRef<AssetType> readPermanent(typename AssetType::Factory::Type type) {
  static std::unordered_map<int, AssetRef<AssetType>> permanentAssets;
 
  const auto typeInt = static_cast<int>(type);
  if (!permanentAssets.contains(typeInt)) {
    const auto assetPtr = std::make_shared<AssetType>(AssetType::Factory::create(type));
    permanentAssets[typeInt] = assetPtr;
    return assetPtr;
  }
 
  return permanentAssets.at(typeInt);
}
 
}  // namespace shkyera::utils::assets