AssetManager.cpp

#include "AssetManager.h"
 
#include "Context.h"
 
#include "Services/Variables.h"
#include "Services/TaskManager.h"
#include "Services/Services.h"
#include "Services/Features.h"
 
#include "Generators/TextureGenerator.h"
 
#include "DataFetcherManager.h"
#include "ModelManager.h"
#include "MaterialManager.h"
#include "TextureManager.h"
#include "ResourceStore.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/FileContents.h"
#include "Foundation/Platform/IO.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("AssetManager");
  const std::string zstdExtension = ".zst";
}
 
Cogs::Core::AssetManager::~AssetManager()
{
 
}
 
void Cogs::Core::AssetManager::initialize()
{
  defaultResource = create();
  defaultResource->setName("Global");
  defaultResource->setActive();
}
 
Cogs::Core::AssetHandle Cogs::Core::AssetManager::loadAsset(const StringView & path, ResourceId resourceId, AssetLoadFlags flags)
{
  AssetLoadInfo & loadInfo = *createLoadInfo();
  loadInfo.resourceId = resourceId;
  loadInfo.resourcePath = path.to_string();
  loadInfo.loadFlags = (ResourceLoadFlags)flags;
 
  if (context->variables->get("resources.assets.autoReload", false)) {
    loadInfo.loadFlags |= ResourceLoadFlags::AutoReload;
  }
 
  return loadResource(&loadInfo);
}
 
void Cogs::Core::AssetManager::reloadAsset(AssetHandle & asset)
{
  handleReload(asset);
}
 
void Cogs::Core::AssetManager::handleReload(ResourceHandleBase handle)
{
  AssetHandle asset(handle);
 
  AssetLoadInfo & loadInfo = *createLoadInfo();
  loadInfo.resourceId = asset->getId();
  loadInfo.resourcePath = asset->getSource().to_string();
  loadInfo.loadFlags = ResourceLoadFlags::Reload;
  loadInfo.handle = asset;
 
  loadResource(&loadInfo);
}
 
void Cogs::Core::AssetManager::handleLoad(AssetLoadInfo * loadInfo)
{
  const auto ext = Cogs::IO::extension(loadInfo->resourcePath);
  auto compressed = (ext.compare(zstdExtension) == 0);
 
  // For Async fetches avoid DataFetcherManager::fetchAsync if asset defined in resources as this only reads from files.
  if (!loadInfo->loadSync() && context->features->prefers(PlatformPreference::AsyncFetch) &&
    !context->resourceStore->hasResource(loadInfo->resourcePath)) {
 
    auto handleResult = [that = this, ctx = context, loadInfo, compressed](std::unique_ptr<FileContents> data)
    {
      AssetDefinition definition;
      if (data && readAssetDefinitionFromFileContents(ctx, std::move(data), definition, compressed)) {
        if (loadInfo->loadSync()) {
          AssetHandle(loadInfo->handle)->definition = std::move(definition);
        }
        else {
          auto asset = that->lock(loadInfo->handle);
          asset->definition = std::move(definition);
        }
      }
      else {
        LOG_WARNING(logger, "Could not %sload asset definition.", loadInfo->isReload() ? "re" : "");
        auto asset = that->lock(loadInfo->handle);
        asset->setFailedLoad();
      }
      that->setProcessed(loadInfo, !loadInfo->loadSync());
    };
 
    DataFetcherManager::fetchAsync(context, loadInfo->resourcePath, handleResult);
  }
 
  else {
 
    auto loadResource = [=, this]()
    {
      AssetDefinition definition;
      if (readAssetDefinitionFromFile(context, loadInfo->resourcePath, definition, compressed)) {
        if (loadInfo->loadSync()) {
          AssetHandle(loadInfo->handle)->definition = std::move(definition);
        }
        else {
          auto asset = lock(loadInfo->handle);
          asset->definition = std::move(definition);
        }
      }
      else {
        if (loadInfo->isReload()) {
          LOG_WARNING(logger, "Could not reload asset definition.");
        }
        else {
          LOG_WARNING(logger, "Could not load asset definition.");
        }
      }
 
      setProcessed(loadInfo, !loadInfo->loadSync());
    };
 
    if (loadInfo->loadSync() || !context->features->prefers(PlatformPreference::BackgroundTasks)) {
      loadResource();
    }
    else {
      context->taskManager->enqueue(TaskManager::ResourceQueue, loadResource);
    }
  }
}
 
void Cogs::Core::AssetManager::instantiateResource(AssetHandle asset, const ResourceDefinition & resourceDefinition)
{
  switch (resourceDefinition.type) {
  case  ResourceTypes::MaterialInstance:
  {
    instantiateMaterialInstance(asset, resourceDefinition);
    break;
  }
  case ResourceTypes::Model:
  {
    instantiateModel(asset, resourceDefinition);
    break;
  }
  case ResourceTypes::Texture:
  {
    instantiateTexture(asset, resourceDefinition);
    break;
  }
  default:
    LOG_ERROR(logger, "Unknown resource type for asset resource %s", resourceDefinition.name.c_str());
    break;
  }
}
 
Cogs::Core::AssetHandle Cogs::Core::AssetManager::instantiateAsset(AssetHandle owner, const ResourceDefinition& assetDefinition)
{
  auto assetHandle = context->assetManager->loadAsset(assetDefinition.source, NoResourceId, AssetLoadFlags::None);
  assetHandle->setName(assetDefinition.name);
 
  if (owner) {
    auto found = std::find_if(owner->assets.begin(), owner->assets.end(), [&](const AssetHandle& m) { return m.resolve() == assetHandle.resolve(); });
 
    if (found == owner->assets.end()) {
      owner->assets.emplace_back(assetHandle);
    }
  }
 
  return assetHandle;
}
 
Cogs::Core::ModelHandle Cogs::Core::AssetManager::instantiateModel(AssetHandle asset, const ResourceDefinition & modelDefinition)
{
  auto model = context->modelManager->loadModel(modelDefinition.source, NoResourceId, ModelLoadFlags::None);
  model->setName(modelDefinition.name);
 
  if (asset) {
    auto found = std::find_if(asset->models.begin(), asset->models.end(), [&](const ModelHandle & m) { return m.resolve() == model.resolve(); });
 
    if (found == asset->models.end()) {
      asset->models.emplace_back(model);
    }
  }
 
  return model;
}
 
Cogs::Core::TextureHandle Cogs::Core::AssetManager::instantiateTexture(AssetHandle asset, const ResourceDefinition & textureDefinition)
{
  TextureHandle texture;
 
  auto existing = context->textureManager->getTexture(textureDefinition.name, true);
 
  if (existing) {
    texture = existing;
  } else {
    if (!textureDefinition.source.empty() && !textureDefinition.textureGenerator) {
      texture = context->textureManager->loadTexture(textureDefinition.source, NoResourceId, textureDefinition.loadFlags);
    } else {
      texture = context->textureManager->create();
 
      texture->description = textureDefinition.textureDescription;
 
      if (texture->description.flags & TextureFlags::RenderTarget) {
        texture->setChanged();
      }
 
      if (textureDefinition.textureGenerator) {
        auto textureGenerator = context->services->getService<TextureGenerator>();
 
        context->taskManager->enqueue(TaskManager::ResourceQueue, [=, this]()
        {
          auto locked = context->textureManager->lock(texture);
 
          textureGenerator->getTexture(locked.operator->(), textureDefinition.imageDefinition);
        });
      }
    }
 
    texture->setName(textureDefinition.name);
  }
 
  if (asset) {
    auto found = std::find_if(asset->textures.begin(), asset->textures.end(), [&](const TextureHandle & t) { return t.resolve() == texture.resolve(); });
 
    if (found == asset->textures.end()) {
      asset->textures.emplace_back(texture);
    }
  }
 
  return texture;
}
 
Cogs::Core::MaterialInstanceHandle Cogs::Core::AssetManager::instantiateMaterialInstance(AssetHandle /*asset*/, const ResourceDefinition & materialInstanceDefinition)
{
  if (!materialInstanceDefinition.reference.empty()) {
    auto reference = context->materialInstanceManager->getMaterialInstance(materialInstanceDefinition.reference);
 
    return reference;
  }
 
  auto material = context->materialManager->getMaterial(materialInstanceDefinition.material);
 
  if (!material) {
    LOG_ERROR(logger, "No material with name \"%s\" found.", materialInstanceDefinition.material.c_str());
    return MaterialInstanceHandle::NoHandle;
  }
 
  auto materialInstance = context->materialInstanceManager->createMaterialInstance(material);
 
  materialInstance->setName(materialInstanceDefinition.name);
 
  updateMaterialInstance(context, materialInstance.resolve(), materialInstanceDefinition);
 
  return materialInstance;
}