TextureManager.cpp

#include "TextureManager.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/Timer.h"
 
#include "Rendering/ITextures.h"
 
#include "Renderer/RenderTexture.h"
 
#include "DataFetcherManager.h"
 
#include "Services/Services.h"
#include "Services/Features.h"
#include "Services/TaskManager.h"
#include "Services/Variables.h"
 
#include "Generators/TextureGenerator.h"
 
#include "Resources/ResourceStore.h"
 
#include "Context.h"
 
#include "Types.h"
 
namespace
{
  using namespace Cogs::Core;
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("TextureManager");
 
  constexpr Cogs::StringView timeLimitName = "resources.textures.mainThreadTimeLimitMs";
  constexpr Cogs::StringView itemLimitName = "resources.textures.mainThreadItemLimit";
 
  bool validateTextureParameters(Cogs::ResourceDimensions target, int width, int height, int depth, int layers) {
    switch (target)
    {
      case Cogs::ResourceDimensions::Texture1D:
        assert(0 < width);
        assert(1 == height);
        assert(1 == depth);
        assert(1 == layers);
        break;
      case Cogs::ResourceDimensions::Texture1DArray:
        assert(0 < width);
        assert(1 == height);
        assert(1 == depth);
        assert(0 < layers);
        break;
      case Cogs::ResourceDimensions::Texture2D:
        assert(0 < width);
        assert(0 < height);
        assert(1 == depth);
        assert(1 == layers);
        break;
      case Cogs::ResourceDimensions::Texture2DArray:
        assert(0 < width);
        assert(0 < height);
        assert(1 == depth);
        assert(0 < layers);
        break;
      case Cogs::ResourceDimensions::Texture3D:
        assert(0 < width);
        assert(0 < height);
        assert(0 < depth);
        assert(1 == layers);
        break;
      case Cogs::ResourceDimensions::Texture3DArray:
        assert(0 < width);
        assert(0 < height);
        assert(0 < depth);
        assert(0 < layers);
        break;
      case Cogs::ResourceDimensions::TextureCube:
        assert(0 < width);
        assert(0 < height);
        assert(1 == depth);
        assert(1 == layers);
        break;
      case Cogs::ResourceDimensions::TextureCubeArray:
        assert(0 < width);
        assert(0 < height);
        assert(1 == depth);
        assert(0 < layers);
        break;
      default:
        LOG_ERROR(logger, "loadTexture: Unhandled target type %d", (int)target);
        return false;
    }
    return true;
  }
 
  void setLoadInfoFlags(TextureLoadInfo* loadInfo, Cogs::TextureFormat format, TextureLoadFlags flags)
  {
    loadInfo->loadFlags = (ResourceLoadFlags)flags;
    loadInfo->flip = (flags & TextureLoadFlags::Flip) != 0;
 
    // Default to mipmaps for all typed non-integer format unless explicitly disabled
    loadInfo->mipMaps = false;
    if ((flags & TextureLoadFlags::NoMipMaps) != TextureLoadFlags::NoMipMaps) {
      if (const Cogs::FormatInfo* info = Cogs::getFormatInfo(format);  info) {
        const Cogs::FormatFlags unfilterable = Cogs::FormatFlags::Integer | Cogs::FormatFlags::Unsigned | Cogs::FormatFlags::Typeless;
        if ((info->flags & unfilterable) == Cogs::FormatFlags::None) {
          loadInfo->mipMaps = true;
        }
      }
    }
  }
 
  void setLoadInfoExtent(TextureLoadInfo* loadInfo, Cogs::ResourceDimensions target, int width, int height, int depth, int layers, Cogs::TextureFormat format, int stride)
  {
    loadInfo->target = target;
    loadInfo->width = width;
    loadInfo->height = height;
    loadInfo->depth = depth;
    loadInfo->layers = layers;
    loadInfo->stride = stride;
    loadInfo->format = format;
  }
 
}
 
Cogs::Core::TextureManager::~TextureManager()
{
  reportLeaks("Texture");
}
 
void Cogs::Core::TextureManager::initialize()
{
  ResourceManager::initialize();
  main = std::this_thread::get_id();
 
  if (!context->variables->exist(timeLimitName)) {
    context->variables->set(timeLimitName, 1.f);
  }
  if (!context->variables->exist(itemLimitName)) {
    context->variables->set(itemLimitName, 10);
  }
 
  // Note: we use non-srgb formats for these textures so that they can be mipmapped on ES2/WebGL.
  // Since values are either 0 or 255, the result is identical.
 
  unsigned char bytes [] = {
    255, 0, 0, 255,
    0, 255, 0, 255,
    0, 0, 255, 255,
    255, 0, 0, 255,
  };
 
  defaultResource = create();
  Texture* texture = get(defaultResource);
  texture->setName("Default");
  texture->setData(Cogs::ResourceDimensions::Texture2D, bytes, 4 * 4, 2, 2, TextureFormat::R8G8B8A8_UNORM, true);
 
  setResourceId(texture, getNextResourceId());
 
  const uint8_t whiteBytes[] = {
    255, 255, 255, 255,
    255, 255, 255, 255,
    255, 255, 255, 255,
    255, 255, 255, 255,
  };
 
  const uint8_t blackBytes[] = {
    0, 0, 0, 255,
    0, 0, 0, 255,
    0, 0, 0, 255,
    0, 0, 0, 255,
  };
 
  const uint8_t transparentBytes[] = {
    0, 0, 0, 0,
    0, 0, 0, 0,
    0, 0, 0, 0,
    0, 0, 0, 0,
  };
 
  if (!HandleIsValid(white)) {
    white = loadTexture2D(whiteBytes, 2, 2, TextureFormat::R8G8B8A8_UNORM, 0, NoResourceId, TextureLoadFlags::ForceSynchronous);
 
    whiteCube = create();
 
    whiteCube->description.target = ResourceDimensions::TextureCube;
    whiteCube->description.width = 2;
    whiteCube->description.height = 2;
    whiteCube->description.faces = 6;
    whiteCube->description.flags = TextureFlags::Texture | TextureFlags::CubeMap;
    whiteCube->description.format = TextureFormat::R8G8B8A8_UNORM;
    whiteCube->storage.init({ 2, 2, 1 }, 1, 6, 1, whiteCube->description.format);
 
    auto whiteCubeData = static_cast<uint8_t *>(whiteCube->storage.getData());
    auto whiteCubeSize = whiteCube->storage.getSize();
 
    for (size_t i = 0; i < whiteCubeSize; ++i) {
      whiteCubeData[i] = 255;
    }
 
    whiteCube->setChanged();
 
    white->setName("Cogs.WhiteTexture");
    whiteCube->setName("Cogs.WhiteCubeMap");
  }
 
  LOG_DEBUG(logger, "Initialized texture manager.");
}
 
void Cogs::Core::TextureManager::clear()
{
  white = ResourceHandle();
  whiteCube = ResourceHandle();
  ResourceManager::clear();
}
 
void  Cogs::Core::TextureManager::cancelTextureLoad(TextureHandle handle)
{
  DataFetcherManager::FetchId fetchId = DataFetcherManager::NoFetchId;
 
  // See if we know about this fetch, and if so, remove this knowledge
  size_t textureKey = reinterpret_cast<size_t>(handle.get());
  {
    LockGuard guard(fetchIds.lock);
    if (auto it = fetchIds.map.find(textureKey); it != fetchIds.map.end()) {
      fetchId = it->second;
      fetchIds.map.erase(it);
    }
  }
 
  // Do cancel the fetch
  if (fetchId != DataFetcherManager::NoFetchId) {
    DataFetcherManager::cancelAsyncFetch(context, fetchId);
  }
}
 
Cogs::Core::TextureHandle Cogs::Core::TextureManager::loadTexture(const void * imageData, ResourceDimensions target, int width, int height, int depth, int layers, TextureFormat format, int stride, const ResourceId resourceId, TextureLoadFlags flags)
{
  assert((stride == 0) || ( (0 < stride) && (static_cast<size_t>(stride) >= width * Cogs::getBlockSize(format))));
  assert(width > 0 && height > 0 && depth > 0 && layers > 0);
 
  int tail = 0;
  if (stride == 0) {
    // 32 bit aligned stride:
    stride = static_cast<int>((width * Cogs::getBlockSize(format) + 3) & ~3);
    tail = static_cast<int>(stride - width * Cogs::getBlockSize(format));
  }
  auto data = static_cast<const uint8_t *>(imageData);
 
  if (!validateTextureParameters(target, width, height, depth, layers)) {
    return TextureHandle::NoHandle;
  }
 
  TextureLoadInfo * loadInfo = createLoadInfo();
  setLoadInfoExtent(loadInfo, target, width, height, depth, layers, format, stride);
  setLoadInfoFlags(loadInfo, format, flags);
  loadInfo->resourceId = resourceId;
 
  if (data) {
    loadInfo->resourceData.assign(data, data + stride * height * depth * layers - tail);
  }
  return loadTexture(loadInfo);
}
 
Cogs::Core::TextureHandle Cogs::Core::TextureManager::loadTexture(const void * imageData, ResourceDimensions target, int width, int height, int depth, int layers, TextureFormat format, int stride, const TextureHandle& resourceHandle, TextureLoadFlags flags) {
  assert((stride == 0) || ( (0 < stride) && (static_cast<size_t>(stride) >= width * Cogs::getBlockSize(format))));
  assert(width > 0 && height > 0 && depth > 0 && layers > 0);
 
  int tail = 0;
  if (stride == 0) {
    // 32 bit aligned stride:
    stride = static_cast<int>((width * Cogs::getBlockSize(format) + 3) & ~3);
    tail = static_cast<int>(stride - width * Cogs::getBlockSize(format));
  }
  auto data = static_cast<const uint8_t *>(imageData);
 
  if (!validateTextureParameters(target, width, height, depth, layers)) {
    return TextureHandle::NoHandle;
  }
 
  TextureLoadInfo * loadInfo = createLoadInfo();
  setLoadInfoExtent(loadInfo, target, width, height, depth, layers, format, stride);
  setLoadInfoFlags(loadInfo, format, flags);
  loadInfo->handle = resourceHandle;
 
  if (data) {
    loadInfo->resourceData.assign(data, data + stride * height * depth * layers - tail);
  }
  return loadResource(loadInfo);
}
 
Cogs::Core::TextureHandle Cogs::Core::TextureManager::loadTexture(const StringView & resourceName, const ResourceId resourceId, TextureLoadFlags flags)
{
  TextureLoadInfo * loadInfo = createLoadInfo();
  loadInfo->resourceId = resourceId;
  loadInfo->resourcePath = resourceName.to_string();
  loadInfo->format = ((flags & TextureLoadFlags::LinearColorSpace) != 0) ? TextureFormat::R8G8B8A8_UNORM : TextureFormat::R8G8B8A8_UNORM_SRGB;
  loadInfo->loadFlags = (ResourceLoadFlags)flags;
  loadInfo->flip = (flags & TextureLoadFlags::Flip) != 0;
  // If the texture is flipped on load make sure we don't store the source path
  // since it doesn't match the in-memory texture anymore.
  if (loadInfo->flip) loadInfo->loadFlags |= ResourceLoadFlags::DoNotStoreSource;
 
  if (context->variables->get("resources.textures.autoReload", false)) {
    loadInfo->loadFlags |= ResourceLoadFlags::AutoReload;
  }
 
  return loadResource(loadInfo);
}
 
TextureHandle Cogs::Core::TextureManager::loadTextureFromMemory(const void* dataPtr, const size_t dataSize, const StringView& resourcePath, const ResourceId resourceId, TextureLoadFlags flags)
{
  TextureLoadInfo* loadInfo = createLoadInfo();
  loadInfo->resourceId = resourceId;
  loadInfo->resourcePath = resourcePath.to_string();
  loadInfo->format = ((flags & TextureLoadFlags::LinearColorSpace) != 0) ? TextureFormat::R8G8B8A8_UNORM : TextureFormat::R8G8B8A8_UNORM_SRGB;
  loadInfo->loadFlags = (ResourceLoadFlags)(flags | TextureLoadFlags::ForceUnique);
  loadInfo->flip = (flags & TextureLoadFlags::Flip) != 0;
  loadInfo->mipMaps = !(bool)((TextureLoadFlags)(flags & TextureLoadFlags::NoMipMaps));
  // NOTE(Markus): This is a workaround, since dataset from Chevron incorrectly says it is linear, when it is really srgb.
  // GLTF spec expects srgb for basisu ktx2 extension.
  loadInfo->getColorSpaceFromLoadInfo = ((flags & TextureLoadFlags::ColorSpaceFromLoadInfo) == TextureLoadFlags::ColorSpaceFromLoadInfo) ? (true) : (false);
  // If the texture is flipped on load make sure we don't store the source path
  // since it doesn't match the in-memory texture anymore.
  if (loadInfo->flip) loadInfo->loadFlags |= ResourceLoadFlags::DoNotStoreSource;
 
  // Copy data into resourceData
  loadInfo->resourceData.assign(static_cast<const uint8_t*>(dataPtr), static_cast<const uint8_t*>(dataPtr) + dataSize);
 
  return loadResource(loadInfo);
}
 
 
Cogs::Core::TextureHandle Cogs::Core::TextureManager::loadTexture(TextureLoadInfo * loadInfo)
{
  return loadResource(loadInfo);
}
 
Cogs::Core::TextureHandle Cogs::Core::TextureManager::getTexture(const StringView & path, bool isQuery)
{
  if (path.empty()) {
    LOG_ERROR(logger, "Cannot fetch texture using empty path.");
    return TextureHandle::NoHandle;
  }
 
#if 1
  auto schemeEndLoc = path.find("://");
  if (schemeEndLoc != StringView::NoPosition) {
    auto schemeHash = path.substr(0, schemeEndLoc).hash();
 
    TextureLoadFlags loadFlags = TextureLoadFlags::None;
    ParsedValue attributes;
    auto queryLoc = path.find("?");
    if (queryLoc != StringView::NoPosition) {
      parseQueryString(attributes.values, path.substr(queryLoc + 1));
 
      for (auto & item : attributes.values) {
        switch (StringView(item.key).hash()) {
        case Cogs::hash("mipmaps"):
        case Cogs::hash("mips"): {
          bool rv = true;
          item.asBool(rv);
          if (rv == false) {
            loadFlags |= TextureLoadFlags::NoMipMaps;
          }
          break;
        }
        case Cogs::hash("linear"): {
          bool rv = true;
          item.asBool(rv);
          if (rv) {
            loadFlags |= TextureLoadFlags::LinearColorSpace;
          }
          break;
        }
        default:
          break;
        }
  
      }
    }
 
    auto nakedPath = path.substr(schemeEndLoc + 3, queryLoc == StringView::NoPosition ? queryLoc : queryLoc - schemeEndLoc - 3);
    switch (schemeHash)
    {
    case Cogs::hash("file"):
      return loadTexture(nakedPath, NoResourceId, loadFlags);
      break;
#if defined( EMSCRIPTEN )
    case Cogs::hash("http"):
    case Cogs::hash("https"):
      return loadTexture(path, NoResourceId, loadFlags);
      break;
#endif
    case Cogs::hash("linear"):
      loadFlags |= TextureLoadFlags::LinearColorSpace;
      return loadTexture(nakedPath, NoResourceId, loadFlags);
      break;
    case Cogs::hash("generator"):
      return context->services->getService<TextureGenerator>()->getTexture(parseEnum(nakedPath, ImageType::None), attributes);
      break;
    default:
      LOG_ERROR(logger, "Unknown URI scheme '%s'", path.substr(0, schemeEndLoc).to_string().c_str());
      return TextureHandle::NoHandle;
      break;
    }
  }
 
#else
  auto fileLoc = path.find("file://");
  auto linearLoc = path.find("linear://");
  auto generatorLoc = path.find("generator://");
 
  if (linearLoc != StringView::NoPosition) {
    return loadTexture(path.substr(9), NoResourceId, TextureLoadFlags::LinearColorSpace);
  } else if (fileLoc != StringView::NoPosition) {
    return loadTexture(path.substr(7), NoResourceId, TextureLoadFlags::None);
  } else if (generatorLoc != StringView::NoPosition) {
    return context->services->getService<TextureGenerator>()->getTexture(parseEnum(path.substr(12), ImageType::None));
  }
#endif
  else if (!path.empty()) {
    auto name = path[0] == '$' ? path.substr(1) : path;
 
    auto handle = getByName(name);
 
    if (!HandleIsValid(handle) && !isQuery) {
      LOG_ERROR(logger, "Could not resolve texture with name %.*s", StringViewFormat(path));
    }
 
    return handle;
  }
  return TextureHandle::NoHandle;
}
 
void Cogs::Core::TextureManager::postProcessLoading()
{
  if (fetchedItems.empty()) return;
 
  double timeLimitSeconds = 0.001 * context->variables->get(timeLimitName, 0.f);
  int itemLimit = context->variables->get(itemLimitName, 0);
 
  int texturesLoaded = 0;
  Cogs::Timer processTimer = Cogs::Timer::startNew();
  while (!fetchedItems.empty()) {
    FetchedItem item = std::move(fetchedItems.front());
    fetchedItems.pop();
 
    TextureLoadInfo* loadInfo = item.loadInfo;
    if (!loadInfo->resourceData.empty()) {
      invokeLoader(item.loadedLoader, item.loadInfo);
    }
    else {
      if (processFetchedItem(item.loadedLoader, loadInfo, std::move(item.data))) {
        texturesLoaded++;
      }
    }
 
    // Model loaded successfully
    if ((0 < itemLimit) && (itemLimit <= texturesLoaded)) {
      // Hit item limit, stop processing this frame.
      break;
    }
    if ((0.f < timeLimitSeconds) && (timeLimitSeconds <= processTimer.elapsedSeconds())) {
      // Hit time limit, stop processing this frame.
      break;
    }
  }
 
  // If we are not done, trigger a new frame so we can continue.
  if (!fetchedItems.empty()) {
    // Not done, we need another frame where we can continue.
    context->engine->setDirty();
  }
}
 
 
void Cogs::Core::TextureManager::handleLoad(TextureLoadInfo * loadInfo)
{
  bool preLoad = context->variables->get("resources.textures.preLoad", false);
 
  if (preLoad && loadInfo->resourcePath.size()) {
    if (!checkPreloaded(loadInfo)) return;
  }
 
  if (!loadInfo->resourcePath.empty()) {
    loadFromPath(loadInfo);
  }
  else {
 
    // Load from raw data blob
    if (loadInfo->loadSync()) {
      loadFromData(loadInfo);
      setProcessed(loadInfo, !loadInfo->loadSync());
    }
    else {
      context->taskManager->enqueue(TaskManager::ResourceQueue, [this, loadInfo]()
                                    {
                                      loadFromData(loadInfo);
                                      setProcessed(loadInfo, !loadInfo->loadSync());
                                    });
    }
  };
 
}
 
void Cogs::Core::TextureManager::handleReload(ResourceHandleBase handle)
{
  TextureHandle texture(handle);
 
  auto * loadInfo = createLoadInfo();
  loadInfo->resourceId = texture->getId();
  loadInfo->resourcePath = texture->getSource().to_string();
  loadInfo->loadFlags = ResourceLoadFlags::Reload;
  loadInfo->handle = handle;
 
  loadResource(loadInfo);
}
 
Cogs::Core::TextureHandle Cogs::Core::TextureManager::loadExternalTexture(intptr_t externalHandle, ResourceDimensions target, int width, int height, int depth, int layers, TextureFormat format, const ResourceId resourceId, TextureLoadFlags flags)
{
  TextureHandle handle = getOrCreate(resourceId);
 
  auto texture = get(handle);
 
  texture->setId(resourceId);
  texture->description = TextureDescription{};
  texture->description.target = target;
  texture->description.width = width;
  texture->description.height = height;
  texture->description.depth = depth;
  texture->description.faces = (target == ResourceDimensions::TextureCube || target == ResourceDimensions::TextureCubeArray) ? 6 : 1;
  texture->description.layers = layers;
  texture->description.format = format;
  texture->externalHandle = externalHandle;
  texture->hasAlpha = getFormatInfo(format)->elements == 4;
 
  if ((flags & TextureLoadFlags::NoMipMaps) == TextureLoadFlags::None) {
    texture->description.flags |= TextureFlags::GenerateMipMaps;
  }
 
  if ((flags & TextureLoadFlags::NoDelete) == TextureLoadFlags::NoDelete) {
    texture->description.flags |= TextureFlags::NoDelete;
  }
 
  // Queue the resource for activation.
  texture->setChanged();
 
  return handle;
}
 
Cogs::Core::ActivationResult Cogs::Core::TextureManager::handleActivation(TextureHandle handle, Texture * /*texture*/)
{
  return context->renderer->getResources()->updateResource(handle);
}
 
void Cogs::Core::TextureManager::handleDeletion(Texture * texture)
{
  context->renderer->getResources()->releaseResource(texture);
}
 
bool Cogs::Core::TextureManager::processFetchedItem(ILoadedTextureLoader* loadedLoader, TextureLoadInfo* loadInfo, std::unique_ptr<FileContents> data)
{
  // Check if we have been cancelled and remove the fetch id
  bool cancelled = true;
  {
    size_t textureKey = reinterpret_cast<size_t>(loadInfo->handle.get());
    LockGuard guard(fetchIds.lock);
    if (auto it = fetchIds.map.find(textureKey); it != fetchIds.map.end()) {
      fetchIds.map.erase(it);
      cancelled = false;
    }
  }
 
  bool success = false;
 
  // If texture has been cancelled, we just stop processing and treat it as failed
  if (cancelled) {
    LOG_TRACE(logger, "Cancelled texture %s", loadInfo->resourcePath.c_str());
    loadInfo->handle->setFailedLoad();
  }
 
  // If texture has been abandoned while we're fetching, just drop it.
  else if (loadInfo->handle->referenceCount() <= 1) {
    LOG_TRACE(logger, "Abandoned texture received in async callback, skipping further processing");
    loadInfo->handle->setFailedLoad();
  }
 
  // If we have no data, the fetch has failed
  else if (!data) {
    LOG_ERROR(logger, "Error fetching texture %s", loadInfo->resourcePath.c_str());
    loadInfo->handle->setFailedLoad();
  }
 
  // And finally we try to actually load the contents
  else if (loadedLoader->load(context, *loadInfo, data->ptr, data->size)) {
    success = true;
  }
  else {
    LOG_ERROR(logger, "Error decoding texture %s", loadInfo->resourcePath.c_str());
    loadInfo->handle->setFailedLoad();
  }
 
  setProcessed(loadInfo, !loadInfo->loadSync());
  return success;
}
 
bool Cogs::Core::TextureManager::invokeLoader(ITextureLoader* loader, TextureLoadInfo* loadInfo)
{
  assert(loader);
  bool success = loader->load(context, *loadInfo);
  if (!success) {
    LOG_ERROR(logger, "Error loading texture %s.", loadInfo->resourcePath.c_str());
    loadInfo->handle->setFailedLoad();
  }
  setProcessed(loadInfo, !loadInfo->loadSync());
  return success;
}
 
bool Cogs::Core::TextureManager::invokeLoader(ILoadedTextureLoader* loadedLoader, TextureLoadInfo* loadInfo)
{
  assert(loadedLoader);
  bool success = loadedLoader->load(context, *loadInfo, loadInfo->resourceData.data(), loadInfo->resourceData.size());
  if (!success) {
    LOG_ERROR(logger, "Error loading texture from %s.", loadInfo->resourceName.c_str());
    loadInfo->handle->setFailedLoad();
  }
  setProcessed(loadInfo, true);
  return success;
}
 
void Cogs::Core::TextureManager::loadFromPath(TextureLoadInfo * loadInfo)
{
  assert(!loadInfo->resourcePath.empty());
 
  ITextureLoader* loader = findLoader(loadInfo);
  if (!loader) {
    LOG_ERROR(logger, "No suitable texture loader found for %s.", loadInfo->resourcePath.c_str());
    loadInfo->handle->setFailedLoad();
    setProcessed(loadInfo, !loadInfo->loadSync());
    return;
  }
 
  // If we have both path and resource data, the path is just used to determine loader,
  // but the resourceData contains the actual data
  if (!loadInfo->resourceData.empty()) {
 
    ILoadedTextureLoader* loadedLoader = dynamic_cast<ILoadedTextureLoader*>(loader);
    if(!loadedLoader) {
      LOG_ERROR(logger, "Texture loader for %s does not support consuming data from an inline blob.", loadInfo->resourcePath.c_str());
      loadInfo->handle->setFailedLoad();
      setProcessed(loadInfo, !loadInfo->loadSync());
    }
    else if (loadInfo->loadSync()) {
      invokeLoader(loadedLoader, loadInfo);
    }
    else if(context->taskManager->getQueueConcurrency(TaskManager::ResourceQueue)) {
      context->taskManager->enqueue(TaskManager::ResourceQueue, [this, loadedLoader, loadInfo]() { invokeLoader(loadedLoader, loadInfo); });
    }
    else {
      fetchedItems.push(FetchedItem{ .data = nullptr, .loadInfo = loadInfo, .loadedLoader = loadedLoader });
    }
    return;
  }
 
  // If load is requested to be sync, we must just try to read the file
  if (loadInfo->loadSync()) {
    invokeLoader(loader, loadInfo);
    return;
  }
 
  // Unless the path is in the resource store, we try to load it asynchronously
  if (!context->resourceStore->hasResource(loadInfo->resourcePath) && loadInfo->protocol != ResourceProtocol::Archive) {
 
    // Async loaders are loaders where the loader does the actual async stuff. Only relevant implementation
    // is the WebTexLoader that handles async load + DOM decoding in js land. This loader takes the ownership
    // of the loadInfo and will call setProcessed with it.
    if (IAsyncTextureLoader* asyncLoader = dynamic_cast<IAsyncTextureLoader*>(loader); asyncLoader) {
      asyncLoader->load(context, loadInfo);
      return;
    }
 
    // LoadedLoaders are loaders that can interpret a chunk of memory. With such a loader, we can do an async
    // fetch of a blob of data and pass the data to the loader when we receive it.
    if (ILoadedTextureLoader* loadedLoader = dynamic_cast<ILoadedTextureLoader*>(loader); loadedLoader) {
 
      // We have a potential race condition since the callback that removes the
      // cancellation id can either run during the fetch call or after, so we add
      // an item now so we can detect and handle this situation.
      size_t textureKey = reinterpret_cast<size_t>(loadInfo->handle.get());
      {
        LockGuard guard(fetchIds.lock);
        fetchIds.map[textureKey] = DataFetcherManager::NoFetchId;
      }
 
      // Handler that runs when the fetch has finished
      FileContents::Callback handleResult = [this, loadedLoader, loadInfo](std::unique_ptr<FileContents> data) {
        // If we are in the main thread, we queue the response to be processed during the engine update
        if (main == std::this_thread::get_id()) {
          fetchedItems.push(FetchedItem{ .data = std::move(data), .loadInfo = loadInfo, .loadedLoader = loadedLoader });
          context->engine->setDirty();
          return;
        }
        processFetchedItem(loadedLoader, loadInfo, std::move(data));
      };
 
      // Fire off the fetch
      DataFetcherManager::FetchId fetchId = DataFetcherManager::fetchAsync(context, loadInfo->resourcePath, handleResult, 0, 0, true);
 
      // Update the map running fetches
      {
        LockGuard guard(fetchIds.lock);
        if (auto it = fetchIds.map.find(textureKey); it != fetchIds.map.end()) {
          it->second = fetchId;
        }
      }
 
      // Fetch handler has taken ownership of the loadInfo
      return;
    }
  }
 
  // Load is not sync and loader does not support async etc, so we just fire off a task loading it from file
  context->taskManager->enqueue(TaskManager::ResourceQueue, [this, loader, loadInfo]() { invokeLoader(loader, loadInfo); });
}
 
void Cogs::Core::TextureManager::loadFromData(TextureLoadInfo * loadInfo)
{
  auto texture = lock(loadInfo->handle);
 
  texture->description.target = loadInfo->target;
 
  switch (loadInfo->target) {
  case ResourceDimensions::Texture1D:
    texture->setData(loadInfo->target,
                     loadInfo->resourceData.data(),
                     loadInfo->resourceData.size(),
                     loadInfo->width,
                     1 /* height */,
                     1 /* depth */,
                     1 /* layers */,
                     1 /* faces */,
                     1 /* levels*/,
                     loadInfo->format,
                     loadInfo->mipMaps);
    break;
  case ResourceDimensions::Texture1DArray:
    texture->setData(loadInfo->target,
                     loadInfo->resourceData.data(),
                     loadInfo->resourceData.size(),
                     loadInfo->width,
                     1 /* height */,
                     1 /* depth */,
                     loadInfo->layers,
                     1 /* faces */,
                     1 /* levels*/,
                     loadInfo->format,
                     loadInfo->mipMaps);
    break;
  case ResourceDimensions::Texture2D: {
    void*     data;
    uint8_t*  copy = nullptr;
 
    if (loadInfo->flip) {
      copy = new uint8_t[loadInfo->resourceData.size()];
 
      const uint8_t*  read = loadInfo->resourceData.data();
      uint8_t*        write = copy + loadInfo->resourceData.size();
      size_t          stride = loadInfo->stride;
 
      assert(loadInfo->resourceData.size() == loadInfo->height * stride);
 
      for (int y = loadInfo->height; y--; ) {
        write -= stride;
        memcpy(write, read, stride);
        read += stride;
      }
      data = copy;
    }
    else {
      data = loadInfo->resourceData.data();
    }
    texture->setData(loadInfo->target,
                     data,
                     loadInfo->resourceData.size(),
                     loadInfo->width,
                     loadInfo->height,
                     1 /* depth */,
                     1 /* layers */,
                     1 /* faces */,
                     1 /* levels*/,
                     loadInfo->format,
                     loadInfo->mipMaps);
    texture->hasAlpha = getFormatInfo(loadInfo->format)->elements == 4;
 
    delete [] copy;
    break;
  }
  case ResourceDimensions::Texture2DArray:
    texture->setData(loadInfo->target,
                     loadInfo->resourceData.data(),
                     loadInfo->resourceData.size(),
                     loadInfo->width,
                     loadInfo->height,
                     1 /* depth */,
                     loadInfo->layers,
                     1 /* faces */,
                     1 /* levels*/,
                     loadInfo->format,
                     loadInfo->mipMaps);
    break;
  case ResourceDimensions::Texture3D:
    texture->setData(loadInfo->target,
                     loadInfo->resourceData.data(),
                     loadInfo->resourceData.size(),
                     loadInfo->width,
                     loadInfo->height,
                     loadInfo->depth,
                     1 /* layers */,
                     1 /* faces */,
                     1 /* levels*/,
                     loadInfo->format,
                     loadInfo->mipMaps);
    break;
  case ResourceDimensions::Texture3DArray:
    texture->setData(loadInfo->target,
                     loadInfo->resourceData.data(),
                     loadInfo->resourceData.size(),
                     loadInfo->width,
                     loadInfo->height,
                     loadInfo->depth,
                     loadInfo->layers,
                     1 /* faces */,
                     1 /* levels*/,
                     loadInfo->format,
                     loadInfo->mipMaps);
    break;
  case ResourceDimensions::TextureCube:
    texture->setData(loadInfo->target,
                     loadInfo->resourceData.data(),
                     loadInfo->resourceData.size(),
                     loadInfo->width,
                     loadInfo->height,
                     1 /* depth*/,
                     1 /* layers */,
                     6 /* faces */,
                     1 /* levels*/,
                     loadInfo->format,
                     loadInfo->mipMaps);
    break;
  case ResourceDimensions::TextureCubeArray:
    texture->setData(loadInfo->target,
                     loadInfo->resourceData.data(),
                     loadInfo->resourceData.size(),
                     loadInfo->width,
                     loadInfo->height,
                     1 /* depth*/,
                     loadInfo->layers,
                     6 /* faces */,
                     1 /* levels*/,
                     loadInfo->format,
                     loadInfo->mipMaps);
    break;
  default:
    assert(false && "Unhandled texture target");
    break;
  }
}