GliTextureLoader.cpp

#ifdef __clang__
#pragma clang diagnostic ignored "-Wformat"
#endif
#include "GliTextureLoader.h"
#include "GliFormats.h"
 
#include "Context.h"
#include "Resources/TextureManager.h"
#include "Resources/ResourceStore.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/IO.h"
 
#include "gli/gli.hpp"
#include "gli/convert.hpp"
 
#include "zstd.h"
 
 
namespace
{
  using namespace Cogs::Core;
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("GliTextureLoader");
 
  const std::string dds_zstd_suffix = ".dds.zst";
 
  const size_t dds_zstd_suffix_len = dds_zstd_suffix.length();
 
  bool decodeFromMemory(Context* context, const TextureLoadInfo& loadInfo, const void* dataPtr, const size_t dataSize)
  {
    if (dataPtr == nullptr || dataSize == 0) {
      return false;
    }
 
    Cogs::Memory::MemoryBuffer decompressed;
    const void* data_ptr = nullptr;
    size_t data_siz = 0u;
 
    auto N = loadInfo.resourcePath.size();
    if ((dds_zstd_suffix_len <= N) && (loadInfo.resourcePath.substr(N - dds_zstd_suffix_len) == dds_zstd_suffix)) {
      ZSTD_DCtx* zstd_dctx = ZSTD_createDCtx();
      assert(zstd_dctx);
 
      auto size = ZSTD_getFrameContentSize(dataPtr, dataSize);
      if (size == ZSTD_CONTENTSIZE_UNKNOWN) {
        LOG_ERROR(logger, "ZSTD_CONTENTSIZE_UNKNOWN");
        return false;
      }
      else if (size == ZSTD_CONTENTSIZE_ERROR) {
        LOG_ERROR(logger, "ZSTD_CONTENTSIZE_ERROR");
        return false;
      }
      else if (std::numeric_limits<size_t>::max() < size) {
        LOG_ERROR(logger, "File too large: %ull", size);
        return false;
      }
      data_siz = static_cast<size_t>(size);
 
      decompressed.resize(data_siz, false);
      auto result = ZSTD_decompressDCtx(zstd_dctx, decompressed.data(), decompressed.size(), dataPtr, dataSize);
      if (ZSTD_isError(result)) {
        LOG_ERROR(logger, "ZSTD decompression failed: %s", ZSTD_getErrorName(result));
        return false;
      }
      LOG_DEBUG(logger, "ZSTD decompressed dds image %s", loadInfo.resourcePath.c_str());
      data_ptr = decompressed.data();
      data_siz = result;
      ZSTD_freeDCtx(zstd_dctx);
    }
    else {
      data_ptr = dataPtr;
      data_siz = dataSize;
    }
 
    gli::texture textureData = gli::load(reinterpret_cast<const char*>(data_ptr), data_siz);
 
    if (textureData.empty()) {
      return false;
    }
 
 
    auto target = Cogs::ResourceDimensions::Unknown;
    switch (textureData.target()) {
    case gli::TARGET_1D:
      target = Cogs::ResourceDimensions::Texture1D;
      break;
    case gli::TARGET_1D_ARRAY:
      target = Cogs::ResourceDimensions::Texture1DArray;
      break;
    case gli::TARGET_2D:
      target = Cogs::ResourceDimensions::Texture2D;
      break;
    case gli::TARGET_2D_ARRAY:
      target = Cogs::ResourceDimensions::Texture2DArray;
      break;
    case gli::TARGET_3D:
      target = Cogs::ResourceDimensions::Texture3D;
      break;
    case gli::TARGET_RECT:
      target = Cogs::ResourceDimensions::Texture2D;
      break;
    case gli::TARGET_RECT_ARRAY:
      target = Cogs::ResourceDimensions::Texture2DArray;
      break;
    case gli::TARGET_CUBE:
      target = Cogs::ResourceDimensions::TextureCube;
      break;
    case gli::TARGET_CUBE_ARRAY:
      target = Cogs::ResourceDimensions::TextureCubeArray;
      break;
    default:
      assert(false && "Unhandled gli texture target");
      break;
    }
 
    Cogs::TextureFormat format = Cogs::formatMap[textureData.format()];
    if (format == Cogs::TextureFormat::Unknown) {
      LOG_ERROR(logger, "Unsupported texture format %d in %s.", format, loadInfo.resourcePath.c_str());
      return false;
    }
 
    if (loadInfo.flip) {
      textureData = gli::flip(textureData);
    }
 
    auto texture = context->textureManager->lock(loadInfo.handle);
    texture->description.target = target;
 
    bool generateMipMaps = (textureData.levels() <= 1) && (TextureLoadFlags(loadInfo.loadFlags) & TextureLoadFlags::NoMipMaps) != TextureLoadFlags::NoMipMaps;
    texture->setData(target,
                     textureData.data(),
                     textureData.size(),
                     textureData.extent(0).s,
                     textureData.extent(0).t,
                     textureData.extent(0).p,
                     static_cast<uint32_t>(textureData.layers()),
                     static_cast<uint32_t>(textureData.faces()),
                     static_cast<uint32_t>(textureData.levels()),
                     format,
                     generateMipMaps);
 
    return true;
  }
 
}
 
bool Cogs::Core::GliTextureLoader::canLoad(Context * /*context*/, const TextureLoadInfo & loadInfo)
{
  auto N = loadInfo.resourcePath.size();
  if ((dds_zstd_suffix_len <= N) && (loadInfo.resourcePath.substr(N - dds_zstd_suffix_len) == dds_zstd_suffix)) {
    return true;
  }
 
  auto extension = Cogs::IO::extension(loadInfo.resourcePath);
  for (auto& c : extension) {
    c = static_cast<decltype(extension)::value_type>(std::tolower(c));
  }
  return extension == ".dds" || extension == ".ktx";
}
 
bool Cogs::Core::GliTextureLoader::load(Context * context, const TextureLoadInfo & loadInfo)
{
  const auto & data = context->resourceStore->getResourceContents(loadInfo.resourcePath);
  if (data.empty()) {
    return false;
  }
  return decodeFromMemory(context, loadInfo, data.data(), data.size());
}
 
bool Cogs::Core::GliTextureLoader::load(Context* context, const TextureLoadInfo& loadInfo, const void* dataPtr, size_t dataSize)
{
  return decodeFromMemory(context, loadInfo, dataPtr, dataSize);
}