GltfLoader.cpp

#include "GltfLoader.h"
 
#include "DracoMeshDecompressor.h"
#include "MeshoptDecompressor.h"
#include "Context.h"
#include "ExtensionRegistry.h"
 
#include "Services/Variables.h"
#include "Platform/ResourceBufferBackedFileContents.h"
#include "Resources/AnimationManager.h"
#include "Resources/DefaultMaterial.h"
#include "Resources/IModelLoader.h"
#include "Resources/MaterialManager.h"
#include "Resources/ResourceStore.h"
#include "Resources/Skeleton.h"
#include "Resources/Animation.h"
#include "Foundation/HashSequence.h"
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/IO.h"
#include "Rendering/DataFormat.h"
 
#if defined ( __clang__ )
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wsign-compare"
#endif
 
#include "stb_image.h"
 
#if defined ( __clang__ )
#pragma clang diagnostic pop
#endif
 
 
namespace Cogs::Core::GltfLoader
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("GltfLoader");
 
  // FIXME: use stringview
  std::string getScheme(const std::string& uri)
  {
    std::string scheme = "file";
    std::string::size_type spos = uri.find(':');
 
    if (spos != std::string::npos) {
      std::string s = uri.substr(0, spos);
      bool use = true;
      for (const char &c : s) {
        if (!(std::isupper(c) || std::islower(c))) {
          use = false;
          break;
        }
      }
      if (use) {
        scheme = s;
      }
    }
 
    return scheme;
  }
 
  void debugMessageOnce(GltfModelDefinition& loadData, const char* format, ...)
  {
    char buffer[2048];
 
    va_list argptr;
    va_start(argptr, format);
    int n = std::vsnprintf(buffer, sizeof(buffer), format, argptr);
    va_end(argptr);
    if (0 < n && n < static_cast<int>(sizeof(buffer))) {
      loadData.debugMessages[buffer] += 1;
    }
  }
 
  template<size_t M>
  void stridedCopy(uint8_t* dst, size_t dstStride, const uint8_t* src, size_t srcStride, size_t count)
  {
    for (size_t i = 0; i < count; i++) {
      for (size_t k = 0; k < M; k++) {
        dst[dstStride * i + k] = src[srcStride * i + k];
      }
    }
  }
 
  [[nodiscard]] bool checkIsUint(const GltfModelDefinition& loadData, const char* name, const Value& value)
  {
    if (!value.IsUint()) {
      LOG_ERROR(logger, "%.*s: %s is not an uint", StringViewFormat(loadData.path), name);
      return false;
    }
    return true;
  }
 
  [[nodiscard]] bool checkIsUint(const GltfModelDefinition& loadData, const Member& member)
  {
    return checkIsUint(loadData, member.name.GetString(), member.value);
  }
 
  [[nodiscard]] bool getUint(const GltfModelDefinition& loadData, uint32_t& result, const Member& member)
  {
    if (!checkIsUint(loadData, member.name.GetString(), member.value)) {
      return false;
    }
    result = member.value.GetUint();
    return true;
  }
 
  [[nodiscard]] bool checkIsBool(const GltfModelDefinition& loadData, const char* name, const Value& value)
  {
    if (!value.IsBool()) {
      LOG_ERROR(logger, "%.*s: %s is not a bool", StringViewFormat(loadData.path), name);
      return false;
    }
    return true;
  }
 
  [[nodiscard]] bool checkIsBool(const GltfModelDefinition& loadData, const Member& member)
  {
    return checkIsBool(loadData, member.name.GetString(), member.value);
  }
 
  [[nodiscard]] bool getBool(const GltfModelDefinition& loadData, bool& result, const Member& member)
  {
    if (!checkIsBool(loadData, member.name.GetString(), member.value)) return false;
    result = member.value.GetBool();
    return true;
  }
 
  [[nodiscard]] bool checkIsString(const GltfModelDefinition& loadData, const char* name, const Value& value)
  {
    if (!value.IsString()) {
      LOG_ERROR(logger, "%.*s: %s is not a string", StringViewFormat(loadData.path), name);
      return false;
    }
    return true;
  }
 
  [[nodiscard]] bool checkIsString(const GltfModelDefinition& loadData, const Member& member)
  {
    return checkIsString(loadData, member.name.GetString(), member.value);
  }
 
  [[nodiscard]] bool checkIsObject(const GltfModelDefinition& loadData, const char* name, const Value& value)
  {
    if (!value.IsObject()) {
      LOG_ERROR(logger, "%.*s: %s is not an object", StringViewFormat(loadData.path), name);
      return false;
    }
    return true;
  }
 
  [[nodiscard]] bool checkIsObject(const GltfModelDefinition& loadData, const Member& member)
  {
    return checkIsObject(loadData, member.name.GetString(), member.value);
  }
 
  [[nodiscard]] bool checkIsArray(const GltfModelDefinition& loadData, const Member& member)
  {
    if (!member.value.IsArray()) {
      LOG_ERROR(logger, "%.*s: %s is not an array", StringViewFormat(loadData.path), member.name.GetString());
      return false;
    }
    return true;
  }
 
  template<typename Vec>
  [[nodiscard]] bool tryGetVecN(Vec& result, const GltfModelDefinition& loadData, const char* key, const Object& parent)
  {
    size_t N = result.length();
 
    if (auto it = parent.FindMember(key); it != parent.MemberEnd()) {
      if (!it->value.IsArray()) {
        LOG_ERROR(logger, "%.*s: %s not an array", StringViewFormat(loadData.path), it->name.GetString());
        return false;
      }
      const Array& arr = it->value.GetArray();
      if (arr.Size() != N) {
        LOG_ERROR(logger, "%.*s: %s not an array with length %zu", StringViewFormat(loadData.path), it->name.GetString(), N);
        return false;
      }
      for (uint32_t i = 0; i < N; i++) {
        if (!arr[i].IsNumber()) {
          LOG_ERROR(logger, "%.*s: %s array element %u is not a float", StringViewFormat(loadData.path), it->name.GetString(), i);
          return false;
        }
        result[i] = arr[i].GetFloat();
      }
    }
    return true;
  }
 
  [[nodiscard]] bool tryGetBool(bool& result, const GltfModelDefinition& loadData, const char* key, const Object& parent)
  {
    if (auto it = parent.FindMember(key); it != parent.MemberEnd()) {
      if (!it->value.IsBool()) {
        LOG_ERROR(logger, "%.*s: %s not a bool", StringViewFormat(loadData.path), it->name.GetString());
        return false;
      }
      result = it->value.GetBool();
    }
    return true;
  }
 
  [[nodiscard]] bool tryGetString(Cogs::StringView& result, const GltfModelDefinition& loadData, const char* key, const Object& parent)
  {
    if (auto it = parent.FindMember(key); it != parent.MemberEnd()) {
      if (!it->value.IsString()) {
        LOG_ERROR(logger, "%.*s: %s not a string", StringViewFormat(loadData.path), it->name.GetString());
        return false;
      }
      result = toView(it->value);
    }
    return true;
  }
 
  [[nodiscard]] bool tryGetFloat(float& result, const GltfModelDefinition& loadData, const char* key, const Object& parent)
  {
    if (auto it = parent.FindMember(key); it != parent.MemberEnd()) {
      if (!it->value.IsNumber()) {
        LOG_ERROR(logger, "%.*s: %s not a float", StringViewFormat(loadData.path), it->name.GetString());
        return false;
      }
      result = it->value.GetFloat();
    }
    return true;
  }
 
  [[nodiscard]] bool tryGetUint(uint32_t& result, const GltfModelDefinition& loadData, const char* key, const Object& parent)
  {
    if (auto it = parent.FindMember(key); it != parent.MemberEnd()) {
      if (!it->value.IsUint()) {
        LOG_ERROR(logger, "%.*s: %s not an uint", StringViewFormat(loadData.path), it->name.GetString());
        return false;
      }
      result = it->value.GetUint();
    }
    return true;
  }
 
  [[nodiscard]] bool getString(std::string& result, const Cogs::StringView& path, const Member& member)
  {
    if (!member.value.IsString()) {
      LOG_ERROR(logger, "%.*s: %s s not a string", StringViewFormat(path), member.name.GetString());
      return false;
    }
    result = std::string(member.value.GetString());
 
    // Fix at least space char encoded in URL. Fails Kronos demos.
    // Todo - more URL decoding.
    for (;;) {
      size_t pos = result.find("%20");
      if (pos == std::string::npos) {
        break;
      }
      result.replace(pos, 3, " ");
    }
 
    return true;
  }
 
  [[nodiscard]] bool parseAsset(GltfModelDefinition& loadData, const Cogs::StringView& path, const Value& assetValue)
  {
    if (!assetValue.IsObject()) {
      LOG_ERROR(logger, "%.*s: JSON asset is not an object value", StringViewFormat(path));
      return false;
    }
 
    for (const auto& field : assetValue.GetObject()) {
      if (field.name == "version") {
        std::string v = field.value.GetString();
        size_t pos = v.find('.');
        std::string v_maj = v.substr(0, pos);
        std::string v_min = v.substr(pos + 1, v.size() - pos);
        int32_t major_version = atoi(v_maj.c_str());
        int32_t minor_version = atoi(v_min.c_str());
        loadData.version = major_version * 100 + minor_version;
      }
      else if (field.name == "minVersion") {
        std::string v = field.value.GetString();
        size_t pos = v.find('.');
        std::string v_maj = v.substr(0, pos);
        std::string v_min = v.substr(pos + 1, v.size() - pos);
        int32_t major_version = atoi(v_maj.c_str());
        int32_t minor_version = atoi(v_min.c_str());
        loadData.min_version = major_version * 100 + minor_version;
      }
      else if (field.name == "generator") {
        // Ignored
      }
      else if (field.name == "copyright") {
        // Ignored
      }
      else if (field.name == "extras") {
        // Ignored
      }
      else if(field.name == "extensions"){
        // Ignored
      }
      else if(field.name == "extensionsRequired"){
        // Ignored
      }
      else {
        LOG_WARNING_ONCE(logger, "Unknown asset field: %s", field.name.GetString());
        break;
      }
    }
    if (loadData.min_version == -1) loadData.min_version = loadData.version;
    if (loadData.min_version >= 300) {
      LOG_ERROR(logger, "Could not load asset file %.*s. (Unsuported min version %d.)", StringViewFormat(path), loadData.min_version);
      return false;
    }
    return true;
  }
 
  [[nodiscard]] bool parseBuffers(Context* context, GltfModelDefinition& loadData, const Cogs::StringView& path, const Value& buffersValue, std::span<const uint8_t>& glbData)
  {
    if (!buffersValue.IsArray()) {
      LOG_ERROR(logger, "%.*s: JSON buffers member is not an array value", StringViewFormat(path));
      return false;
    }
 
    for (const auto& bufferValue : buffersValue.GetArray()) {
      bool glb = true;
      std::string uri;
 
      for (const auto& field : bufferValue.GetObject()) {
        if (field.name == "uri") {
          uri = field.value.GetString();
          if (uri.find("%") != std::string::npos) {
            LOG_WARNING_ONCE(logger, "Unknown buffer field: %s", uri.c_str());
          }
          else if (uri.find("&") != std::string::npos) {
            LOG_WARNING_ONCE(logger, "Unknown buffer field: %s", uri.c_str());
          }
          glb = false;
        }
        else if (field.name == "byteLength") {
          // Ignored
        }
        else if (field.name == "extensions") {
          auto exts = field.value.GetObject();
          for (auto& ext : exts) {
            if (std::string(ext.name.GetString()) == "EXT_meshopt_compression") {
              // This section can contain a "fallback=true/false" value which indicates that this buffer shall be reserved
              // for the decompressed data. This is ignored for now as we handle the decompressed data ourselves.
            }
          }
        }
        else {
          LOG_WARNING_ONCE(logger, "Unknown buffer field: %s", field.name.GetString());
        }
      }
 
      std::string scheme = getScheme(uri);
 
      if (glb) {
        loadData.buffer_data.push_back(glbData);
      }
      else if (scheme == "data") {
        std::string::size_type spos = uri.find(':');
        std::string::size_type mpos = uri.find(';');
        std::string::size_type dpos = uri.find(',');
        std::string media_type = uri.substr(spos + 1, mpos - (spos + 1));
        std::string base_type = uri.substr(mpos + 1, dpos - (mpos + 1));
        std::string base64 = uri.substr(dpos + 1);
        LOG_TRACE(logger, "Loading data: media type \"%s\", base_type \"%s\"", media_type.c_str(), base_type.c_str());
        std::string data = base64_decode(base64);
 
        Cogs::Memory::MemoryBuffer buffer(data.size(), context->memory->ioAllocator);
 
        std::memcpy(buffer.data(), &data[0], data.size());
 
        auto& stored = loadData.buffer_data_store.emplace_back(ResourceBuffer{ std::make_shared<Cogs::Memory::MemoryBuffer>(std::move(buffer)) });
 
        loadData.buffer_data.push_back(std::span<const uint8_t>(stored.data(), stored.data() + stored.size()));
      }
      else if (scheme == "file") {
        std::string::size_type spos = uri.find(':');
        if (spos != std::string::npos) {
          uri = Cogs::IO::combine(Cogs::IO::parentPath(path), uri.substr(spos + 1));
        }
        else {
          uri = Cogs::IO::combine(Cogs::IO::parentPath(path), uri);
        }
        auto& stored = loadData.buffer_data_store.emplace_back(context->resourceStore->getResourceContents(uri));
        if (stored.empty()) {
          LOG_ERROR(logger, "Failed or empty linked uri: %s files.", uri.c_str());
          return false;
        }
        loadData.buffer_data.push_back(std::span<const uint8_t>(stored.data(), stored.data() + stored.size()));
      }
      else {
        LOG_ERROR(logger, "%.*s: Loader cannot handle uri %s files.", StringViewFormat(path), uri.c_str());
        return false;
      }
    }
    return true;
  }
 
  [[nodiscard]] bool parseBufferViews(GltfModelDefinition& loadData, const Cogs::StringView& path, const Value& bufferViewsValue, MeshoptDecompressor & meshoptDecomp)
  {
    if (!bufferViewsValue.IsArray()) {
      LOG_ERROR(logger, "%.*s: JSON bufferViews is not an array", StringViewFormat(path));
      return false;
    }
 
     for (const auto& bufferViewValue : bufferViewsValue.GetArray()) {
      GltfBufferView& tmp = loadData.buffer_views.emplace_back(GltfBufferView());
 
      if (!bufferViewValue.IsObject()) {
        LOG_ERROR(logger, "%.*s: JSON bufferViews element is not an object", StringViewFormat(path));
        return false;
      }
 
      for (const auto& field : bufferViewValue.GetObject()) {
        switch (toView(field.name).hash()) {
        case Cogs::hash("buffer"):
          if (!field.value.IsUint()) {
            LOG_ERROR(logger, "%.*s: JSON bufferView buffer is not an uint", StringViewFormat(path));
            return false;
          }
          tmp.buffer = field.value.GetUint();
          break;
 
        case Cogs::hash("byteLength"):
          if (!field.value.IsUint()) {
            LOG_ERROR(logger, "%.*s: JSON bufferView byteLength is not an uint", StringViewFormat(path));
            return false;
          }
          tmp.byteLength = field.value.GetUint();
          break;
 
        case Cogs::hash("byteOffset"):
          if (!field.value.IsUint()) {
            LOG_ERROR(logger, "%.*s: JSON bufferView byteOffset is not an uint", StringViewFormat(path));
            return false;
          }
          tmp.byteOffset = field.value.GetUint();
          break;
 
        case Cogs::hash("target"):
          if (!field.value.IsUint()) {
            LOG_ERROR(logger, "%.*s: JSON bufferView target is not an uint", StringViewFormat(path));
            return false;
          }
          tmp.target = field.value.GetUint();
          break;
 
        case Cogs::hash("byteStride"):
          if (!field.value.IsUint()) {
            LOG_ERROR(logger, "%.*s: JSON bufferView byteStride is not an uint", StringViewFormat(path));
            return false;
          }
          tmp.byteStride = field.value.GetUint();
          break;
        case Cogs::hash("name"):
          // TODO
          break;
        case Cogs::hash("extensions"):
          for (const auto& ext : field.value.GetObject()) {
            if (std::string(ext.name.GetString()) == "EXT_meshopt_compression") {
              meshoptDecomp.registerBufferViewCompression(uint32_t(loadData.buffer_views.size() - 1), ext.value.GetObject());
            }
          }
          break;
        default:
          LOG_ERROR(logger, "%.*s: JSON unknown bufferView field: %s", StringViewFormat(path), field.name.GetString());
          break;
        }
      }
    }
    return true;
  }
 
  void decodeImageData(Context* context, GltfImage& gltfImage, const Cogs::StringView& path, const Cogs::StringView& mimeType, const void* data, const size_t size)
  {
#if 0 // Debug image
    const uint32_t img[2 * 2] = {
      0xff00ff, 0x00ff00,
      0x00ff00, 0xff00ff,
    };
    void* mem = malloc(sizeof(img));
    std::memcpy(mem, img, sizeof(img));
    gltfImage.decoded.data = reinterpret_cast<stbi_uc*>(mem);
    gltfImage.decoded.width = 2;
    gltfImage.decoded.height = 2;
    gltfImage.decoded.comp = 4;
    return;
#endif
 
    switch (mimeType.hash()) {
    case Cogs::hash("image/png"):
    case Cogs::hash("image/jpeg"):
      stbi_set_flip_vertically_on_load_thread(0);
      gltfImage.handle = context->textureManager->loadTextureFromMemory(data, size, "unnamed.extension", NoResourceId, Cogs::Core::TextureLoadFlags::None);
      break;
 
    case Cogs::hash("image/ktx2"):
    {
      gltfImage.handle = context->textureManager->loadTextureFromMemory(data, size, "unnamed.ktx2", NoResourceId, Cogs::Core::TextureLoadFlags::ColorSpaceFromLoadInfo);
 
      break;
    }
 
    default:
      LOG_ERROR(logger, "%.*s: Unsupported mimetype %.*s", StringViewFormat(path), StringViewFormat(mimeType));
      gltfImage.decoded.failed = true;
    }
  }
 
  void decodeImageData(Context* context, GltfImage& gltfImage, const Cogs::StringView& path, const Cogs::StringView& mimeType, const void* data, const size_t size, Cogs::Core::TextureLoadFlags loadFlags)
  {
#if 0 // Debug image
    const uint32_t img[2 * 2] = {
      0xff00ff, 0x00ff00,
      0x00ff00, 0xff00ff,
    };
    void* mem = malloc(sizeof(img));
    std::memcpy(mem, img, sizeof(img));
    gltfImage.decoded.data = reinterpret_cast<stbi_uc*>(mem);
    gltfImage.decoded.width = 2;
    gltfImage.decoded.height = 2;
    gltfImage.decoded.comp = 4;
    return;
#endif
 
    switch (mimeType.hash()) {
    case Cogs::hash("image/png"):
    case Cogs::hash("image/jpeg"):
      gltfImage.handle = context->textureManager->loadTextureFromMemory(data, size, "unnamed.extension", NoResourceId, loadFlags);
      break;
 
    case Cogs::hash("image/ktx2"):
    {
      gltfImage.handle = context->textureManager->loadTextureFromMemory(data, size, "unnamed.ktx2", NoResourceId, loadFlags | Cogs::Core::TextureLoadFlags::ColorSpaceFromLoadInfo);
      break;
    }
 
    default:
      LOG_ERROR(logger, "%.*s: Unsupported mimetype %.*s", StringViewFormat(path), StringViewFormat(mimeType));
      gltfImage.decoded.failed = true;
    }
  }
 
  [[nodiscard]] bool parseImages(Context* context, GltfModelDefinition& loadData, const Value& imagesValue)
  {
    if (!imagesValue.IsArray()) {
      LOG_ERROR(logger, "%.*s: Images is not an array", StringViewFormat(loadData.path));
      return false;
    }
 
    Array images = imagesValue.GetArray();  // Resize up-front so it doesn't move in mem, we use async tasks here
    loadData.images.resize(images.Size());
 
    for(uint32_t i=0; i<images.Size(); i++) {
      const Value& imageValue = images[i];
      if (!imageValue.IsObject()) {
        LOG_ERROR(logger, "%.*s: Images array item is not an object", StringViewFormat(loadData.path));
        return false;
      }
      auto imageObject = imageValue.GetObject();
 
      GltfImage& image = loadData.images[i];
 
      if (auto uriMember = imageObject.FindMember("uri"); uriMember != imageValue.MemberEnd()) {
        if (!getString(image.uri, loadData.path, *uriMember)) {
          return false;
        }
 
        const Cogs::StringView imageUri(image.uri);
        if (imageUri.substr(0, 5) == "data:") {
          size_t spos = imageUri.find_first_of(':');
          size_t mpos = imageUri.find_first_of(';');
          size_t dpos = imageUri.find_first_of(',');
          Cogs::StringView mediaType = imageUri.substr(spos + 1, mpos - (spos + 1));
          Cogs::StringView baseType = imageUri.substr(mpos + 1, dpos - (mpos + 1));
          Cogs::StringView base64 = imageUri.substr(dpos + 1);
          LOG_TRACE(logger, "%.*s: Loading embedded data: media type \"%.*s\", base_type \"%.*s\"",
            StringViewFormat(loadData.path), StringViewFormat(mediaType), StringViewFormat(baseType));
 
          image.kind = GltfImage::LoadFromMemory;
          image.decoded.task = loadData.context->taskManager->enqueueChild(loadData.rootTask,
            [&loadData, &image, mediaType, base64, context]() {
              std::string data = base64_decode(base64.to_string());
              decodeImageData(context, image, loadData.path, mediaType, data.c_str(), data.size());
            });
        }
        else {
          image.kind = GltfImage::LoadFromUri;
        }
      }
 
      else if (auto bufferViewMember = imageObject.FindMember("bufferView"); bufferViewMember != imageValue.MemberEnd()) {
        auto mimeTypeMember = imageObject.FindMember("mimeType");
        if (mimeTypeMember == imageObject.MemberEnd()) {
          LOG_ERROR(logger, "%.*s: Images array item has an bufferView item but no mimeType member", StringViewFormat(loadData.path));
          return false;
        }
 
        uint32_t bufferViewIndex = 0;
        if (!getUint(loadData, bufferViewIndex, *bufferViewMember)) {
          return false;
        }
 
        std::string mimeType;
        if (!getString(mimeType, loadData.path, *mimeTypeMember)) {
          return false;
        }
 
        image.kind = GltfImage::LoadFromMemory;
        image.from_memory_data.bufferViewIndex = bufferViewIndex;
        image.from_memory_data.mimeType = mimeType;
      }
      else {
        LOG_ERROR(logger, "%.*s: Images array item has neither an uri nor a bufferView member", StringViewFormat(loadData.path));
        return false;
      }
    }
 
    return true;
  }
 
  [[nodiscard]] TextureHandle getTextureHandle(GltfModelDefinition& loadData, const size_t imageIndex, const bool linearColor, const bool mipmapped)
  {
    if (loadData.images.size() <= imageIndex) {
      LOG_ERROR(logger, "%.*s: Illegal image index %zu", StringViewFormat(loadData.path), imageIndex);
      return TextureHandle::NoHandle;
    }
 
    GltfImage& image = loadData.images[imageIndex];
    const size_t cacheIndex = (linearColor ? 2 : 0) + (mipmapped ? 1 : 0);
 
    if (!image.cache[cacheIndex].handle) {
      switch (image.kind) {
      case GltfImage::Unset:
        LOG_WARNING_ONCE(logger, "%.*s: Image index %zu has no valid data", StringViewFormat(loadData.path), imageIndex);
        image.cache[cacheIndex].handle = loadData.context->textureManager->white;
        break;
      case GltfImage::LoadFromUri:
        image.cache[cacheIndex].handle = loadData.context->textureManager->loadTexture(Cogs::IO::combine(Cogs::IO::parentPath(loadData.path), image.uri),
                                                                                       NoResourceId,
                                                                                       (linearColor ? TextureLoadFlags::LinearColorSpace : TextureLoadFlags::None) |
                                                                                       (mipmapped ? TextureLoadFlags::None : TextureLoadFlags::NoMipMaps));
        break;
      case GltfImage::LoadFromMemory:
        assert(!image.cache[cacheIndex].proxy);
        {
          const GltfBufferView& bufferView = loadData.buffer_views[image.from_memory_data.bufferViewIndex];
          std::span<const uint8_t> buffer = loadData.buffer_data[bufferView.buffer];
 
          const uint8_t* ptr = &buffer[bufferView.byteOffset];
          uint32_t size = bufferView.byteLength;
          decodeImageData(loadData.context, image, loadData.path, image.from_memory_data.mimeType, ptr, size, (linearColor ? TextureLoadFlags::LinearColorSpace : TextureLoadFlags::None) |
           (mipmapped ? TextureLoadFlags::None : TextureLoadFlags::NoMipMaps));
        }
        image.cache[cacheIndex].handle = image.handle;
        break;
      default:
        assert(false && "Invalid image kind");
      }
    }
 
    return image.cache[cacheIndex].handle;
  }
 
  [[nodiscard]] bool parseSamplers(GltfModelDefinition& loadData, const Cogs::StringView& path, const Value& samplersValue)
  {
    if (!samplersValue.IsArray()) {
      LOG_ERROR(logger, "%.*s: Samplers is not an array", StringViewFormat(path));
      return false;
    }
    for (auto& samplerValue : samplersValue.GetArray()) {
      if (!samplerValue.IsObject()) {
        LOG_ERROR(logger, "%.*s: Sampler is not an object", StringViewFormat(path));
        return false;
      }
 
      // Note: Cogs does not expose full filtermode flexibility.
      bool linearFilter = true;
      GltfTextureSampler& sampler = loadData.texture_samplers.emplace_back();
 
      for (const auto& field : samplerValue.GetObject()) {
        switch (toView(field.name).hash()) {
        case Cogs::hash("magFilter"): {
          uint32_t magFilter;
          if (!getUint(loadData, magFilter, field)) {
            return false;
          }
          switch (magFilter) {
          case GLTF_NEAREST: break;
          case GLTF_LINEAR: break;
          default:
            LOG_ERROR(logger, "%.*s: Unrecognized magFilter %u", StringViewFormat(path), magFilter);
            return false;
          }
          break;
        }
 
        case Cogs::hash("minFilter"): {
          uint32_t minFilter;
          if (!getUint(loadData, minFilter, field)) return false;
          switch (minFilter) {
          case GLTF_NEAREST: sampler.mipmapped = false; linearFilter = false; break;
          case GLTF_LINEAR: sampler.mipmapped = false; break;
          case GLTF_NEAREST_MIPMAP_NEAREST: linearFilter = false; break;
          case GLTF_LINEAR_MIPMAP_NEAREST: break;
          case GLTF_NEAREST_MIPMAP_LINEAR: break;
          case GLTF_LINEAR_MIPMAP_LINEAR: break;
          default:
            LOG_ERROR(logger, "%.*s: Unrecognized minFilter %u", StringViewFormat(path), minFilter);
            return false;
          }
          break;
        }
 
        case Cogs::hash("wrapS"): {
          uint32_t wrapS;
          if (!getUint(loadData, wrapS, field)) return false;
          switch (wrapS) {
          case GLTF_CLAMP_TO_EDGE: sampler.sMode = Cogs::SamplerState::AddressMode::Clamp; break;
          case GLTF_MIRRORED_REPEAT: sampler.sMode = Cogs::SamplerState::AddressMode::Mirror; break;
          case GLTF_REPEAT: sampler.sMode = Cogs::SamplerState::AddressMode::Clamp; break;
          default:
            LOG_ERROR(logger, "%.*s: Unrecognized wrapS %u", StringViewFormat(path), wrapS);
            return false;
          }
          break;
        }
 
        case Cogs::hash("wrapT"): {
          uint32_t wrapT;
          if (!getUint(loadData, wrapT, field)) return false;
          switch (wrapT) {
          case GLTF_CLAMP_TO_EDGE: sampler.tMode = Cogs::SamplerState::AddressMode::Clamp; break;
          case GLTF_MIRRORED_REPEAT: sampler.tMode = Cogs::SamplerState::AddressMode::Mirror; break;
          case GLTF_REPEAT: sampler.tMode = Cogs::SamplerState::AddressMode::Clamp; break;
          default:
            LOG_ERROR(logger, "%.*s: Unrecognized wrapT %u", StringViewFormat(path), wrapT);
            return false;
          }
          break;
        }
 
        default:
          LOG_WARNING(logger, "%.*s: Unrecognized sampler field %s", StringViewFormat(path), field.name.GetString());
          break;
        }
      }
      sampler.filterMode = linearFilter ? Cogs::SamplerState::FilterMode::MinMagMipLinear : Cogs::SamplerState::FilterMode::MinMagMipPoint;
    }
    return true;
  }
 
  [[nodiscard]] bool parseTextures(GltfModelDefinition& loadData, const Cogs::StringView& path, const Value& texturesValue)
  {
    if (!texturesValue.IsArray()) {
      LOG_ERROR(logger, "%.*s: Textures is not an array", StringViewFormat(path));
      return false;
    }
    for (auto& texture : texturesValue.GetArray()) {
      auto& texture_value = loadData.textures.emplace_back(GltfTexture{ -1, -1 });
 
      for (const auto& field : texture.GetObject()) {
        if (field.name == "sampler") {
          texture_value.sampler = field.value.GetUint();
          if (loadData.texture_samplers.size() <= (size_t)texture_value.sampler) {
            LOG_ERROR(logger, "Illegal texture sampler index %u", texture_value.sampler);
            return false;
          }
        }
        else if (field.name == "source") {
          texture_value.source = field.value.GetUint();
          if (loadData.images.size() <= uint32_t(texture_value.source)) {
            LOG_ERROR(logger, "Illegal texture source index %u", texture_value.source);
            return false;
          }
        }
        else if (field.name == "extensions") {
          auto ext = field.value.GetObject();
          if (ext.HasMember("KHR_texture_basisu")) {
            auto data = ext["KHR_texture_basisu"].GetObject();
            int altSource = data["source"].GetInt();
            if (!texture.HasMember("source")) {
              texture_value.source = altSource;
            }
          }
        }
        else {
          LOG_WARNING_ONCE(logger, "Unknown texture field: %s", field.name.GetString());
        }
      }
    }
    return true;
  }
 
  [[nodiscard]] bool tryHandleTextureInfo(MaterialHandle material,
                                          MaterialInstanceHandle instance,
                                          GltfModelDefinition& loadData,
                                          CachedModelMaterial& cachedModelMaterial,
                                          const char* key,
                                          const Object& parent,
                                          const char* textureName,
                                          bool linearColor,
                                          bool* success,
                                          const char* extraKey = nullptr,
                                          float* extraValue = nullptr)
  {
    if (auto texInfoIt = parent.FindMember(key); texInfoIt != parent.MemberEnd()) {
      if (!checkIsObject(loadData, *texInfoIt)) {
        return false;
      }
      const Object& texInfoObject = texInfoIt->value.GetObject();
 
      if (auto indexIt = texInfoObject.FindMember("index"); indexIt != texInfoObject.MemberEnd()) {
        uint32_t index = 0;
        if (!getUint(loadData, index, *indexIt)) {
          LOG_ERROR(logger, "No 'index' uint element in texInfoObject");
          return false;
        }
 
        uint32_t texcoord = 0;
        if (!tryGetUint(texcoord, loadData, "texCoord", texInfoObject)) {
          LOG_ERROR(logger, "No 'texCoord' uint element in texInfoObject");
          return false;
        }
        cachedModelMaterial.texCoordSets = std::max(cachedModelMaterial.texCoordSets, texcoord + 1);
 
        if (extraKey && !tryGetFloat(*extraValue, loadData, extraKey, texInfoObject)) {
          LOG_ERROR(logger, "No '%s' float element in texInfoObject", extraKey);
          return false;
        }
 
        if (loadData.textures.size() <= index) {
          LOG_ERROR(logger, "%.*s: %s has illegal texture index %u", StringViewFormat(loadData.path), key, index);
          return false;
        }
 
        const GltfTexture& textureDefinition = loadData.textures[index];
        if (loadData.images.size() <= (size_t)textureDefinition.source) {
          LOG_ERROR(logger, "%.*s: %s has illegal texture index source %u", StringViewFormat(loadData.path), key, textureDefinition.source);
          return false;
        }
 
        GltfTextureSampler sampler;
        if (textureDefinition.sampler != -1) {
          if (loadData.texture_samplers.size() <= (size_t)textureDefinition.sampler) {
            LOG_ERROR(logger, "%.*s: %s has illegal sampler index %u", StringViewFormat(loadData.path), key, textureDefinition.sampler);
            return false;
          }
          sampler = loadData.texture_samplers[textureDefinition.sampler];
        }
        Cogs::Core::TextureHandle textureHandle = getTextureHandle(loadData, textureDefinition.source,
                                                                   linearColor, sampler.mipmapped);
 
        const std::string texmapName = std::string(textureName) + "Map";
        if (instance->material->getVariantIndex(texmapName) != Material::NoVariantIndex) {
          instance->setVariant(texmapName, true);
        }
 
        const std::string texUVChannelName = std::string(textureName) + "UVChannel";
        if (instance->material->getVariantIndex(texUVChannelName) != Material::NoVariantIndex) {
          instance->setVariant(texUVChannelName, int(texcoord));
        }
 
        const std::string texCoordName = std::string("TexCoord") + std::to_string(texcoord);
        if (instance->material->getVariantIndex(texCoordName) != Material::NoVariantIndex) {
          instance->setVariant(texCoordName, true);
        }
 
        std::string texKeyName = std::string(textureName) + "Map";
        texKeyName[0] = char(std::tolower(texKeyName[0]));
 
        const VariableKey texKey = material->getTextureKey(texKeyName);
        instance->setTextureProperty(texKey, textureHandle);
        instance->setTextureAddressMode(texKey, sampler.sMode, sampler.tMode, sampler.uMode);
 
        //
        // Check if we are using the KHR_texture_transform extension for this material. If so, register the transform
        // and the texcoords will be preprocessed before uploaded to the GPU.
        //
        if (auto extIt = texInfoObject.FindMember("extensions"); extIt != texInfoObject.MemberEnd()) {
          const Object& extObject = extIt->value.GetObject();
          if (auto texTrIt = extObject.FindMember("KHR_texture_transform"); texTrIt != extObject.MemberEnd()) {
            const Object& texTrObject = texTrIt->value.GetObject();
            TextureTransform textureTransform;
            if (texTrObject.HasMember("offset")) {
              if (!texTrObject["offset"].IsArray() || texTrObject["offset"].Size() != 2) {
                LOG_ERROR(logger, "The 'KHR_texture_transform' member 'offset' is not an array of size 2"); return false;
                return false;
              }
              textureTransform.offset = glm::vec2(texTrObject["offset"][0].GetFloat(), texTrObject["offset"][1].GetFloat());
            }
            if (texTrObject.HasMember("scale")) {
              if (!texTrObject["scale"].IsArray() || texTrObject["scale"].Size() != 2) {
                LOG_ERROR(logger, "The 'KHR_texture_transform' member 'scale' is not an array of size 2"); return false;
                return false;
              }
              textureTransform.scale = glm::vec2(texTrObject["scale"][0].GetFloat(), texTrObject["scale"][1].GetFloat());
            }
            if (texTrObject.HasMember("rotation")) {
              textureTransform.rotation = texTrObject["rotation"].GetFloat();
            }
 
            loadData.textureTransforms.push_back(textureTransform);
          }
        }
 
        if (success) {
          *success = true;
        }
      }
      else {
        LOG_ERROR(logger, "%.*s: %s is missing required index property", StringViewFormat(loadData.path), texInfoIt->name.GetString());
        return false;
      }
    }
    else {
      // NOTE: This message is printed A LOT due to varying strictness of glTF exporters. Nice to have while debugging the glTF-loader, though.
      //LOG_DEBUG(logger, "Key '%s' not present in material object", key);
    }
 
    return true;
  }
 
  [[nodiscard]] bool handleMaterialPbrMetallicRoughness(GltfModelDefinition& loadData, CachedModelMaterial& cachedMaterial, MaterialHandle material, MaterialInstanceHandle instance, const Object& materialObject)
  {
    glm::vec4 baseColorFactor(1.f, 1.f, 1.f, 1.f);
    float metallicFactor = 1.f;
    float roughnessFactor = 1.f;
 
    if (auto pbrMetallicValue = materialObject.FindMember("pbrMetallicRoughness"); pbrMetallicValue != materialObject.MemberEnd()) {
      if (!checkIsObject(loadData, *pbrMetallicValue)) return false;
      const Object& pbrMetallicObject = pbrMetallicValue->value.GetObject();
 
      if (!tryGetVecN(baseColorFactor, loadData, "baseColorFactor", pbrMetallicObject)) return false;
      if (!tryGetFloat(metallicFactor, loadData, "metallicFactor", pbrMetallicObject)) return false;
      if (!tryGetFloat(roughnessFactor, loadData, "roughnessFactor", pbrMetallicObject)) return false;
 
      if (!tryHandleTextureInfo(material, instance, loadData, cachedMaterial, "baseColorTexture", pbrMetallicObject, "Albedo", false, nullptr)) return false;
      if (!tryHandleTextureInfo(material, instance, loadData, cachedMaterial, "metallicRoughnessTexture", pbrMetallicObject, "MetallicRoughness", true, nullptr)) return false;
    }
 
    // TODO: Create a new material exclusive to GLTF models instead of using StandardMaterial that can read color values 'as is'
    for (int i = 0; i < 3; i++) {
        baseColorFactor[i] = std::pow(std::abs(baseColorFactor[i]), 1.0f / 2.2f); // StandardMaterial expects albedo to be in sRGB color space
    }
 
    instance->setVec4Property(material->getVec4Key("albedo"), baseColorFactor);
    instance->setFloatProperty(material->getFloatKey("metallic"), metallicFactor);
    instance->setFloatProperty(material->getFloatKey("roughness"), roughnessFactor);
 
    return true;
  }
 
  [[nodiscard]] bool handleMaterialGenericFields(GltfModelDefinition& loadData, CachedModelMaterial& cachedMaterial, MaterialHandle material, MaterialInstanceHandle instance, const Object& materialObject)
  {
    Cogs::StringView name;
    if (!tryGetString(name, loadData, "name", materialObject)) return false;
    if (name) {
      instance->setName(name);
    }
 
    Cogs::StringView alphaMode = "OPAQUE";
    if (!tryGetString(alphaMode, loadData, "alphaMode", materialObject)) return false;
    switch (alphaMode.hash()) {
    case Cogs::hash("OPAQUE"):
      break;
    case Cogs::hash("MASK"):
      instance->setVariant("AlphaTest", "Discard");
      break;
    case Cogs::hash("BLEND"):
      instance->setTransparent();
      break;
    default:
      LOG_ERROR(logger, "%.*s: Unknown alphaMode '%.*s'", StringViewFormat(loadData.path), StringViewFormat(alphaMode));
      return false;
    }
 
    float alphaCutoff = 0.5f;
    if (!tryGetFloat(alphaCutoff, loadData, "alphaCutoff", materialObject)) return false;
    instance->setFloatProperty(material->getFloatKey("alphaThreshold"), alphaCutoff);
 
    bool doubleSided = false;
    if (!tryGetBool(doubleSided, loadData, "doubleSided", materialObject)) return false;
    instance->options.cullMode = doubleSided ? CullMode::None : CullMode::Back;
 
    float normalMapFactor = 1.0f;
    if (!tryHandleTextureInfo(material, instance, loadData, cachedMaterial, "normalTexture", materialObject, "Normal", true, &cachedMaterial.needsTangents, "scale", &normalMapFactor)) return false;
    instance->setFloatProperty(material->getFloatKey("normalMapFactor"), normalMapFactor);
 
    float occlusionFactor = 1.0f;
    if (!tryGetFloat(occlusionFactor, loadData, "occlusionFactor", materialObject)) return false;
    if (!tryHandleTextureInfo(material, instance, loadData, cachedMaterial, "occlusionTexture", materialObject, "Occlusion", true, nullptr, "strength", &occlusionFactor)) return false;
    instance->setFloatProperty(material->getFloatKey("occlusion"), occlusionFactor);
 
    glm::vec3 emissiveFactor = glm::vec3(0.0f, 0.0f, 0.0f);
    if (!tryGetVecN(emissiveFactor, loadData, "emissiveFactor", materialObject)) return false;
    if (!tryHandleTextureInfo(material, instance, loadData, cachedMaterial, "emissiveTexture", materialObject, "Emissive", false, nullptr)) return false;
    instance->setVec3Property(material->getVec3Key("emissive"), emissiveFactor);
 
    return true;
  }
 
  [[nodiscard]] bool handleMaterialPbrSpecularGlossiness(GltfModelDefinition& loadData, CachedModelMaterial& cachedMaterial, MaterialHandle material, MaterialInstanceHandle instance, const Object& specGlossObject)
  {
    glm::vec4 diffuseFactor = glm::vec4(1.f, 1.f, 1.f, 1.f);
    if (!tryGetVecN(diffuseFactor, loadData, "diffuseFactor", specGlossObject)) return false;
    // TODO: Create a new material exclusive to GLTF models instead of using StandardMaterial that can read color values 'as is'
    for (int i = 0; i < 3; i++) {
        diffuseFactor[i] = std::pow(std::abs(diffuseFactor[i]), 1.0f / 2.2f); // StandardMaterial expects albedo to be in sRGB color space
    }
    instance->setVec4Property(material->getVec4Key("albedo"), diffuseFactor);
 
    if (!tryHandleTextureInfo(material, instance, loadData, cachedMaterial, "diffuseTexture", specGlossObject, "Albedo", false, nullptr)) return false;
 
    glm::vec3 specularFactor = glm::vec3(1.f, 1.f, 1.f);
    if (!tryGetVecN(specularFactor, loadData, "specularFactor", specGlossObject)) return false;
    instance->setVec3Property(material->getVec3Key("specular"), specularFactor);
 
    float glossinessFactor = 1.f;
    if (!tryGetFloat(glossinessFactor, loadData, "glossinessFactor", specGlossObject)) return false;
    instance->setFloatProperty(material->getFloatKey("gloss"), glossinessFactor);
 
    if (!tryHandleTextureInfo(material, instance, loadData, cachedMaterial, "specularGlossinessTexture", specGlossObject, "SpecularGloss", false, nullptr)) return false;
    return true;
  }
 
  [[nodiscard]] bool handleMaterialSpecular(GltfModelDefinition& loadData, CachedModelMaterial& cachedMaterial, MaterialHandle material, MaterialInstanceHandle instance, const Object& specularObject)
  {
      float specularFactor = 1.f;
      if (!tryGetFloat(specularFactor, loadData, "specularFactor", specularObject)) return false;
      instance->setFloatProperty(material->getFloatKey("specularFactor"), specularFactor);
 
      glm::vec3 specularColorFactor = glm::vec3(1.f, 1.f, 1.f);
      if (!tryGetVecN(specularColorFactor, loadData, "specularColorFactor", specularObject)) return false;     
      instance->setVec3Property(material->getVec3Key("specularColor"), specularColorFactor);
 
      if (!tryHandleTextureInfo(material, instance, loadData, cachedMaterial, "specularTexture", specularObject, "SpecularFactor", false, nullptr)) return false;
 
      if (!tryHandleTextureInfo(material, instance, loadData, cachedMaterial, "specularColorTexture", specularObject, "SpecularColor", false, nullptr)) return false;
 
      return true;
  }
 
  [[nodiscard]] bool handleMaterialIdxOfRefraction(GltfModelDefinition& loadData, CachedModelMaterial& /* cachedMaterial */, MaterialHandle material, MaterialInstanceHandle instance, const Object& iorObject)
  {
      float idxOfRefraction = 1.5f;
      if (!tryGetFloat(idxOfRefraction, loadData, "ior", iorObject)) return false;      
      instance->setFloatProperty(material->getFloatKey("ior"), idxOfRefraction);
      instance->setVariant("Ior", true);
 
      return true;
  }
 
  [[nodiscard]] bool handleMaterialExtensions(GltfModelDefinition& loadData, CachedModelMaterial& cachedMaterial, MaterialHandle material, MaterialInstanceHandle instance, const Object& materialObject)
  {
    if (auto extensionsIt = materialObject.FindMember("extensions"); extensionsIt != materialObject.MemberEnd()) {
      if (!checkIsObject(loadData, *extensionsIt)) {
        return false;
      }
 
      const Object& extensionsObject = extensionsIt->value.GetObject();
 
      if (auto specGlossIt = extensionsObject.FindMember("KHR_materials_pbrSpecularGlossiness"); specGlossIt != extensionsObject.MemberEnd()) {
        if (!checkIsObject(loadData, *specGlossIt)) {
          return false;
        }
        const Object& specGlossObject = specGlossIt->value.GetObject();
 
        if (!handleMaterialPbrSpecularGlossiness(loadData, cachedMaterial, material, instance, specGlossObject)) {
          return false;
        }
 
        return true;
      }
 
      // None of the following extensions can be used if KHR_materials_pbrSpecularGlossiness is found
      if (auto specularIt = extensionsObject.FindMember("KHR_materials_specular"); specularIt != extensionsObject.MemberEnd()) {
          if (!checkIsObject(loadData, *specularIt)) {
              return false;
          }
          const Object& specObject = specularIt->value.GetObject();
          if (!handleMaterialSpecular(loadData, cachedMaterial, material, instance, specObject)) {
              return false;
          }
      }
 
      if (auto iorIt = extensionsObject.FindMember("KHR_materials_ior"); iorIt != extensionsObject.MemberEnd()) {
          if (!checkIsObject(loadData, *iorIt)) {
              return false;
          }
          const Object& iorObject = iorIt->value.GetObject();
          if (!handleMaterialIdxOfRefraction(loadData, cachedMaterial, material, instance, iorObject)) {
              return false;
          }
      }
    }
    return true;
  }
 
  [[nodiscard]] bool getMaterialHandle(GltfModelDefinition& loadData,
                                       Model& model,
                                       CachedModelMaterial*& cachedMaterial_,
                                       const int32_t gltfMaterialIx,
                                       const bool isSkinned,
                                       const bool albedoPerVertex,
                                       const bool hasBitangents)
  {
    if (loadData.materialsArray.size() < size_t(gltfMaterialIx + 1)) {
      LOG_ERROR(logger, "%.*s: Illegal gltf material index %d", StringViewFormat(loadData.path), gltfMaterialIx);
      return false;
    }
    if (loadData.modelMaterialsCache.empty()) {
      loadData.modelMaterialsCache.resize(8 * (loadData.materialsArray.size() + 1));
    }
 
    // Get entry from cache
    size_t cacheIx = 8 * size_t(gltfMaterialIx + 1) + (isSkinned ? 4 : 0) + (albedoPerVertex ? 2 : 0) + (hasBitangents ? 1 : 0);
    assert(cacheIx < loadData.modelMaterialsCache.size());
    CachedModelMaterial& cachedMaterial = loadData.modelMaterialsCache[cacheIx];
    cachedMaterial_ = &cachedMaterial;
 
    // Check if model is already been created
    if (cachedMaterial.modelMaterialIx != -1) {
      return true;
    }
 
    MaterialInstanceHandle materialInstance = MaterialInstanceHandle(nullptr);
 
    // Create material from specification
    if (gltfMaterialIx >= 0) {
      const Object& materialObject = loadData.materialsArray[gltfMaterialIx];
 
      // Handle the special 'KHR_materials_unlit' extension which needs a more basic version of the material.
      if (materialObject.HasMember("extensions") && materialObject["extensions"].HasMember("KHR_materials_unlit")) {
        MaterialHandle material = loadData.context->materialManager->getMaterial("DefaultMaterial");
        materialInstance = loadData.context->materialInstanceManager->createMaterialInstance(material);
        materialInstance->setPermutation("Default");
        materialInstance->setVariant("DefaultHasTexCoord", true);
        materialInstance->setVariant("Textured", true);
        materialInstance->setVariant("LightModel", "BaseColor");
        materialInstance->setVariant("EnableLighting", false);
        materialInstance->setVariant("NoTonemap", true);
 
        if (auto pbrMetallicValue = materialObject.FindMember("pbrMetallicRoughness"); pbrMetallicValue != materialObject.MemberEnd()) {
          if (!checkIsObject(loadData, *pbrMetallicValue)) {
            LOG_ERROR(logger, "The 'KHR_materials_unlit' material does not have a 'pbrMetallicRoughness' section.");
            return false;
          }
          const Object& pbrMetallicObject = pbrMetallicValue->value.GetObject();
          glm::vec4 baseColorFactor(1.0, 1.0, 1.0, 1.0);
          if (!tryGetVecN(baseColorFactor, loadData, "baseColorFactor", pbrMetallicObject)) {
            LOG_ERROR(logger, "The 'pbrMetallicRoughness' section does not have a 'baseColorFactor' value.");
            return false;
          }
          materialInstance->setVec4Property(DefaultMaterial::DiffuseColor, baseColorFactor);
 
          if (!tryHandleTextureInfo(material, materialInstance, loadData, cachedMaterial, "baseColorTexture", pbrMetallicObject, "Diffuse", false, nullptr)) {
            // The KHR_materials_unlit section did not have any textures specified.
            LOG_ERROR(logger, "The 'pbrMetallicRoughness' section does not have a 'baseColorTexture' value.");
            return false;
          }
        }
        
        // As this is an unlit material, we can safely remove all normals to save memory.
        cachedMaterial_->needsNormals = false;
      }
      else {
        MaterialHandle material = loadData.context->materialManager->getMaterial("StandardMaterial");
        materialInstance = loadData.context->materialInstanceManager->createMaterialInstance(material);
 
        // Note, we set permuation first because switching permutation overwrites variant selectors
        materialInstance->setPermutation("Metallic");
        if (auto extensionsIt = materialObject.FindMember("extensions"); extensionsIt != materialObject.MemberEnd()) {
          if (!checkIsObject(loadData, *extensionsIt)) return false;
          const Object& extensionsObject = extensionsIt->value.GetObject();
          if (auto specGlossIt = extensionsObject.FindMember("KHR_materials_pbrSpecularGlossiness"); specGlossIt != extensionsObject.MemberEnd()) {
            materialInstance->setPermutation("Specular");
          }
        }
        // Enable shader variant that are disabled by defaout for performance
        if (auto extensionsIt = materialObject.FindMember("extensions"); extensionsIt != materialObject.MemberEnd()) {
          if (!checkIsObject(loadData, *extensionsIt)) return false;
          const Object& extensionsObject = extensionsIt->value.GetObject();
          if (auto iorIt = extensionsObject.FindMember("KHR_materials_ior"); iorIt != extensionsObject.MemberEnd()) {
            materialInstance->setVariant("Ior", true);
          }
          if (auto specularIt = extensionsObject.FindMember("KHR_materials_specular"); specularIt != extensionsObject.MemberEnd()) {
            materialInstance->setVariant("Specular", true);
          }
        }
 
        materialInstance->setVariant("LightModel", "PBR");
        materialInstance->setVariant("GltfMaterialModel", true);
        if (isSkinned) materialInstance->setVariant("Skinned", true);
        if (albedoPerVertex) materialInstance->setVariant("AlbedoPerVertex", true);
        if (hasBitangents) materialInstance->setVariant("Bitangents", true);
 
        if (!handleMaterialPbrMetallicRoughness(loadData, cachedMaterial, material, materialInstance, materialObject)) return false;
        if (!handleMaterialGenericFields(loadData, cachedMaterial, material, materialInstance, materialObject)) return false;
        if (!handleMaterialExtensions(loadData, cachedMaterial, material, materialInstance, materialObject)) return false;
 
        cachedMaterial_->needsNormals = true;
      }
    }
    // Create default material
    else {
      MaterialHandle material = loadData.context->materialManager->getMaterial("StandardMaterial");
      materialInstance = loadData.context->materialInstanceManager->createMaterialInstance(material);
 
      materialInstance->setPermutation("Metallic");
      materialInstance->setVariant("GltfMaterialModel", true);
      if (isSkinned) materialInstance->setVariant("Skinned", true);
      if (albedoPerVertex) materialInstance->setVariant("AlbedoPerVertex", true);
      if (hasBitangents) materialInstance->setVariant("Bitangents", true);
      materialInstance->setName("GLTF default material");
      materialInstance->setOption("CullMode", "Back");
      materialInstance->setVariant("GltfMaterialModel", true);
 
      materialInstance->setVec4Property(material->getVec4Key("albedo"), glm::vec4(1.0, 1.0, 1.0, 1.0));
      materialInstance->setFloatProperty(material->getFloatKey("metallic"), 1.0f);
      materialInstance->setFloatProperty(material->getFloatKey("roughness"), 1.0f);
      materialInstance->setVec3Property(material->getVec3Key("emissive"), glm::vec3(0.0, 0.0, 0.0));
      materialInstance->setFloatProperty(material->getFloatKey("alphaThreshold"), 0.5f);
 
      cachedMaterial_->needsNormals = true;
    }
 
    assert(materialInstance && "Internal error");
 
    cachedMaterial.modelMaterialIx = int32_t(model.materials.size());
    model.materials.push_back(materialInstance);
    return true;
  }
 
  [[nodiscard]] bool parseScenes(GltfModelDefinition& loadData, const Cogs::StringView& path, const Value& scenesValue)
  {
    if (!scenesValue.IsArray()) {
      LOG_ERROR(logger, "%.*s: JSON scenes is not an array value", StringViewFormat(path));
      return false;
    }
 
    for (const auto& sceneValue : scenesValue.GetArray()) {
      if (!sceneValue.IsObject()) {
        LOG_ERROR(logger, "%.*s: JSON scenes item is not an object", StringViewFormat(path));
        return false;
      }
 
      GltfScene& scene = loadData.scenes.emplace_back();
      for (const auto& field : sceneValue.GetObject()) {
          switch (toView(field.name).hash()) {
          case Cogs::hash("name"): {
              if (!field.value.IsString()) {
                  LOG_ERROR(logger, "%.*s: JSON scene name value is not a string", StringViewFormat(path));
                  return false;
              }
              scene.name = field.value.GetString();
              break;
          }
          case Cogs::hash("nodes"):
          {
              if (!field.value.IsArray()) {
                  LOG_ERROR(logger, "%.*s: JSON scene nodes value is not an array", StringViewFormat(path));
                  return false;
              }
              for (const auto& node : field.value.GetArray()) {
                  if (!node.IsUint()) {
                      LOG_ERROR(logger, "%.*s: JSON scene nodes array item is not an uint", StringViewFormat(path));
                      return false;
                  }
                  scene.nodes.push_back(node.GetUint());
              }
              break;
          }
          case Cogs::hash("extensions"):
          {
              if (!field.value.IsObject()) {
                  LOG_ERROR(logger, "%.*s: JSON scene extensions item is not an object", StringViewFormat(path));
                  return false;
              }
 
              // Any extension declared anywhere in the json file will be hoisted and placed on the arrays
              // extensionsUsed and extensionsRequired and handled acordingly when reading those.
              break;
          }
          
          case Cogs::hash("extras"): {
              // extras can have ANY type but usually appears as key/value pairs
              //https://registry.khronos.org/glTF/specs/2.0/glTF-2.0.html#reference-extras
 
              auto type = field.value.GetType();
              
              LOG_WARNING_ONCE(logger, "Unhandled application-specific node under scenes node: Extras[rapidjson::Type: %u]", type );
              break;
          }
        default:
          LOG_WARNING_ONCE(logger, "%.*s: JSON unknown scene field: %s", StringViewFormat(path), field.name.GetString());
          break;
        }
      }
    }
    return true;
  }
 
  [[nodiscard]] bool parseNodes(GltfModelDefinition& loadData, const Cogs::StringView& path, const Value& nodesValue)
  {
    if (!nodesValue.IsArray()) {
      LOG_ERROR(logger, "%.*s: JSON nodes member is not an array value", StringViewFormat(path));
      return false;
    }
 
    const auto nodeValues = nodesValue.GetArray();
    const uint32_t numNodes = nodeValues.Size();
    loadData.nodes.resize(numNodes);
 
    for (uint32_t i = 0; i < numNodes; ++i) {
      GltfNode& node = loadData.nodes[i];
      node.node_index = i;
 
      bool use_matrix_transform = false;
 
      const Value& nodeValue = nodeValues[i];
      if (!nodeValue.IsObject()) {
        LOG_ERROR(logger, "%.*s: JSON nodes array item not an object", StringViewFormat(path));
        return false;
      }
 
      for (const auto& field : nodeValue.GetObject()) {
        switch (toView(field.name).hash()) {
        case Cogs::hash("name"):
          if (!field.value.IsString()) {
            LOG_ERROR(logger, "%.*s: JSON node name is not a string", StringViewFormat(path));
            return false;
          }
          node.name = field.value.GetString();
          break;
 
        case Cogs::hash("children"):
          if (!field.value.IsArray()) {
            LOG_ERROR(logger, "%.*s: JSON node children is not an array", StringViewFormat(path));
            return false;
          }
          for (const auto& child : field.value.GetArray()) {
            if (!child.IsUint()) {
              LOG_ERROR(logger, "%.*s: JSON children array element is not an uint", StringViewFormat(path));
              return false;
            }
            uint32_t childIndex = child.GetUint();
            node.children.push_back(childIndex);
            loadData.nodes[childIndex].parent_node = i;
          }
          break;
 
        case Cogs::hash("rotation"):
          if (field.value.IsArray() && field.value.GetArray().Size() == 4) {
            auto arr = field.value.GetArray();
            node.rot = glm::quat(arr[3].GetFloat(), arr[0].GetFloat(), arr[1].GetFloat(), arr[2].GetFloat());
          }
          else {
            LOG_ERROR(logger, "%.*s: JSON node rotation value is not an array with 4 elements", StringViewFormat(path));
            return false;
          }
          break;
 
        case Cogs::hash("translation"):
          if (field.value.IsArray() && field.value.GetArray().Size() == 3) {
            auto arr = field.value.GetArray();
            node.pos = glm::vec3(arr[0].GetFloat(), arr[1].GetFloat(), arr[2].GetFloat());
          }
          else {
            LOG_ERROR(logger, "%.*s: JSON node translation value is not an array with 3 elements", StringViewFormat(path));
            return false;
          }
          break;
 
        case Cogs::hash("scale"):
          if (field.value.IsArray() && field.value.GetArray().Size() == 3) {
            auto arr = field.value.GetArray();
            node.scale = glm::vec3(arr[0].GetFloat(), arr[1].GetFloat(), arr[2].GetFloat());
          }
          else {
            LOG_ERROR(logger, "%.*s: JSON node scale value is not an array with 3 elements", StringViewFormat(path));
            return false;
          }
          break;
 
        case Cogs::hash("matrix"):
          if (field.value.IsArray() && field.value.GetArray().Size() == 16) {
            auto arr = field.value.GetArray();
            node.mat = glm::mat4(arr[0].GetFloat(),  arr[1].GetFloat(),  arr[2].GetFloat(),  arr[3].GetFloat(),
                                 arr[4].GetFloat(),  arr[5].GetFloat(),  arr[6].GetFloat(),  arr[7].GetFloat(),
                                 arr[8].GetFloat(),  arr[9].GetFloat(),  arr[10].GetFloat(), arr[11].GetFloat(),
                                 arr[12].GetFloat(), arr[13].GetFloat(), arr[14].GetFloat(), arr[15].GetFloat());
            glm::vec3 skew;
            glm::vec4 perspective;
            glm::decompose(node.mat, node.scale, node.rot, node.pos, skew, perspective);
            use_matrix_transform = true;
          }
          else {
            LOG_ERROR(logger, "%.*s: JSON node matrix value is not an array with 16 elements", StringViewFormat(path));
            return false;
          }
          break;
 
        case Cogs::hash("mesh"):
          if (field.value.IsUint()) {
            node.mesh = field.value.GetUint();
          }
          else {
            LOG_ERROR(logger, "%.*s: JSON node mesh value is not an uint", StringViewFormat(path));
            return false;
          }
          break;
 
        case Cogs::hash("skin"):
          if (field.value.IsUint()) {
            node.skin = field.value.GetUint();
          }
          else {
            LOG_ERROR(logger, "%.*s: JSON node skin value is not an uint", StringViewFormat(path));
            return false;
          }
          break;
 
        case Cogs::hash("camera"):
          // Ignore
          break;
        default:
          LOG_DEBUG(logger, "Unknown node field: %s", field.name.GetString());
          break;
        }
      }
 
      if (!use_matrix_transform) {
        glm::mat4 ii(1.0f);
        node.mat = glm::translate(ii, node.pos) * glm::mat4_cast(node.rot) * glm::scale(ii, node.scale);
      }
    }
    return true;
  }
 
  // There is an issue when an accessor-type is FLOAT but the BBox values are all integers (or the other way around).
  // The glTF spec requires accessor-type and bbox values-type to match, but this is not always the case...
  // We'll therefore just follow the actual type in the JSON document instead of assuming and cast to whatever the
  // accessor-type is.
  void parseAccessorMinArray(GltfAccessor & accessor, Array arr)
  {
    accessor.minCount = std::min(16u, arr.Size());
    for (uint32_t i = 0; i < accessor.minCount; i++) {
      if (arr[i].IsUint() || arr[i].IsInt()) {
        if (accessor.componentType == AccessorComponentType::Float) {
          accessor.min.s_float[i] = float(arr[i].GetInt());
        }
        else {
          if (accessor.componentType == AccessorComponentType::UnsignedByte ||
            accessor.componentType == AccessorComponentType::UnsignedShort ||
            accessor.componentType == AccessorComponentType::UnsignedInt) {
            accessor.min.s_uint[i] = arr[i].GetUint();
          }
          else {
            accessor.min.s_int[i] = arr[i].GetInt();
          }
        }
      }
      else {
        if (accessor.componentType == AccessorComponentType::Float) {
          accessor.min.s_float[i] = arr[i].GetFloat();
        }
        else {
          if (accessor.componentType == AccessorComponentType::UnsignedByte ||
            accessor.componentType == AccessorComponentType::UnsignedShort ||
            accessor.componentType == AccessorComponentType::UnsignedInt) {
            accessor.min.s_uint[i] = uint32_t(std::floor(arr[i].GetFloat()));
          }
          else {
            accessor.min.s_int[i] = int32_t(std::floor(arr[i].GetFloat()));
          }
        }
      }
    }
  }
 
  // See comment above "parseAccessorMinArray()".
  void parseAccessorMaxArray(GltfAccessor& accessor, Array arr)
  {
    accessor.maxCount = std::min(16u, arr.Size());
    for (uint32_t i = 0; i < accessor.maxCount; i++) {
      if (arr[i].IsInt() || arr[i].IsUint()) {
        if (accessor.componentType == AccessorComponentType::Float) {
          accessor.max.s_float[i] = float(arr[i].GetInt());
        }
        else {
          if (accessor.componentType == AccessorComponentType::UnsignedByte ||
            accessor.componentType == AccessorComponentType::UnsignedShort ||
            accessor.componentType == AccessorComponentType::UnsignedInt) {
            accessor.max.s_uint[i] = arr[i].GetUint();
          }
          else {
            accessor.max.s_int[i] = arr[i].GetInt();
          }
        }
      }
      else {
        if (accessor.componentType == AccessorComponentType::Float) {
          accessor.max.s_float[i] = arr[i].GetFloat();
        }
        else {
          if (accessor.componentType == AccessorComponentType::UnsignedByte ||
            accessor.componentType == AccessorComponentType::UnsignedShort ||
            accessor.componentType == AccessorComponentType::UnsignedInt) {
            accessor.max.s_uint[i] = uint32_t(std::ceil(arr[i].GetFloat()));
          }
          else {
            accessor.max.s_int[i] = int32_t(std::ceil(arr[i].GetFloat()));
          }
        }
      }
    }
  }
 
  [[nodiscard]] bool parseAccessors(GltfModelDefinition& loadData, const Cogs::StringView& path, const Value& accessorsValue)
  {
    assert(accessorsValue.IsArray());
    for (const auto& accessorValue : accessorsValue.GetArray()) {
      if (!checkIsObject(loadData, "accessor array item", accessorValue)) return false;
 
      GltfAccessor& accessor = loadData.accessors.emplace_back();
      for (const auto& field : accessorValue.GetObject()) {
        switch (toView(field.name).hash()) {
        case Cogs::hash("bufferView"):
          if (!getUint(loadData, accessor.bufferView, field)) return false;
          break;
 
        case Cogs::hash("byteOffset"):
          if (!getUint(loadData, accessor.byteOffset, field)) return false;
          break;
 
        case Cogs::hash("componentType"):
          if (checkIsUint(loadData, field)) {
            switch (field.value.GetUint()) {
            case GLTF_BYTE:           accessor.componentType = AccessorComponentType::Byte;          break;
            case GLTF_UNSIGNED_BYTE:  accessor.componentType = AccessorComponentType::UnsignedByte;  break;
            case GLTF_SHORT:          accessor.componentType = AccessorComponentType::Short;         break;
            case GLTF_UNSIGNED_SHORT: accessor.componentType = AccessorComponentType::UnsignedShort; break;
            case GLTF_UNSIGNED_INT:   accessor.componentType = AccessorComponentType::UnsignedInt;   break;
            case GLTF_FLOAT:          accessor.componentType = AccessorComponentType::Float;         break;
            default:
              LOG_ERROR(logger, "%.*s:n Unrecognized accessor componentType %u", StringViewFormat(path), field.value.GetUint());
              return false;
            }
          }
          else return false;
          break;
 
        case Cogs::hash("count"):
          if (!getUint(loadData, accessor.count, field)) return false;
          break;
 
        case Cogs::hash("type"):
          if (checkIsString(loadData, field)) {
            switch (toView(field.value).hash()) {
            case Cogs::hash("SCALAR"):  accessor.type = AccessorType::Scalar;  break;
            case Cogs::hash("VEC2"):    accessor.type = AccessorType::Vec2;    break;
            case Cogs::hash("VEC3"):    accessor.type = AccessorType::Vec3;    break;
            case Cogs::hash("VEC4"):    accessor.type = AccessorType::Vec4;    break;
            case Cogs::hash("MAT2"):    accessor.type = AccessorType::Mat2;    break;
            case Cogs::hash("MAT3"):    accessor.type = AccessorType::Mat3;    break;
            case Cogs::hash("MAT4"):    accessor.type = AccessorType::Mat4;    break;
            default:
              LOG_ERROR(logger, "%.*s: Unrecognized accessor type '%s'", StringViewFormat(path), field.value.GetString());
              return false;
            }
          }
          else return false;
          break;
 
        case Cogs::hash("min"):
          if (checkIsArray(loadData, field)) {
            assert(field.value.IsArray());
            parseAccessorMinArray(accessor, field.value.GetArray());
          }
          else return false;
          break;
 
        case Cogs::hash("max"):
          if (checkIsArray(loadData, field)) {
            assert(field.value.IsArray());
            parseAccessorMaxArray(accessor, field.value.GetArray());
          }
          else {
            return false;
          }
          break;
 
        case Cogs::hash("normalized"):
          if (!getBool(loadData, accessor.normalized, field)) return false;
          break;
 
        case Cogs::hash("name"):
          // TODO
          break;
 
        default:
          LOG_WARNING_ONCE(logger, "%.*s: Unknown accessor key '%s'", StringViewFormat(path), field.name.GetString());
          break;
        }
      }
    }
    return true;
  }
 
  [[nodiscard]] bool parseSkins(GltfModelDefinition& loadData, const Cogs::StringView& path, const Value& skinsValue)
  {
    if (!skinsValue.IsArray()) {
      LOG_ERROR(logger, "%.*s: Skins is not an array", StringViewFormat(path));
      return false;
    }
    for (auto& skin_value : skinsValue.GetArray()) {
      auto& skin = loadData.skins.emplace_back();
 
      for (const auto& field : skin_value.GetObject()) {
        if (field.name == "inverseBindMatrices")
          skin.inverseBindMatrices = field.value.GetUint();
        else if (field.name == "joints") {
          for (auto& joint : field.value.GetArray()) skin.joints.push_back(joint.GetUint());
        }
        else if (field.name == "skeleton")
          skin.skeleton = field.value.GetUint();
        else if (field.name == "name")
          skin.name = field.value.GetString();
        else {
          LOG_WARNING_ONCE(logger, "Unknown skin field: %s", field.name.GetString());
        }
      }
    }
    return true;
  }
 
  [[nodiscard]] bool parseAnimations(GltfModelDefinition& loadData, const Cogs::StringView& path, const Value& animationsValue)
  {
    if (!animationsValue.IsArray()) {
      LOG_ERROR(logger, "%.*s: Animations is not an array", StringViewFormat(path));
      return false;
    }
    for (auto& animation_value : animationsValue.GetArray()) {
      auto& animation = loadData.animations.emplace_back();
 
      for (const auto& field : animation_value.GetObject()) {
        if (field.name == "channels") {
          for (auto& channel_value : field.value.GetArray()) {
            auto& channel = animation.channels.emplace_back();
 
            for (auto& channel_field : channel_value.GetObject()) {
              if (channel_field.name == "sampler")
                channel.sampler = channel_field.value.GetUint();
              else if (channel_field.name == "target") {
                for (auto& target : channel_field.value.GetObject()) {
                  if (target.name == "node")
                    channel.node = target.value.GetUint();
                  else if (target.name == "path")
                    channel.path = target.value.GetString();
                  else {
                    LOG_WARNING_ONCE(logger, "Unknown animation channel target field: %s", target.name.GetString());
                  }
                }
              }
              else {
                LOG_WARNING_ONCE(logger, "Unknown animation channel field: %s", channel_field.name.GetString());
              }
            }
          }
        }
        else if (field.name == "samplers") {
          for (auto& sampler_value : field.value.GetArray()) {
            auto& sampler = animation.samplers.emplace_back();
 
            for (auto& sampler_field : sampler_value.GetObject()) {
              if (sampler_field.name == "input")
                sampler.input = sampler_field.value.GetUint();
              else if (sampler_field.name == "interpolation")
                sampler.interpolation = sampler_field.value.GetString();
              else if (sampler_field.name == "output")
                sampler.output = sampler_field.value.GetUint();
              else {
                LOG_WARNING_ONCE(logger, "Unknown animation sampler field: %s", sampler_field.name.GetString());
              }
            }
          }
        }
        else if (field.name == "name") {
          animation.name = field.value.GetString();
        }
        else {
          LOG_WARNING_ONCE(logger, "Unknown animation field: %s", field.name.GetString());
        }
      }
    }
 
    return true;
  }
 
  uint32_t getAccessorTypeSize(const GltfAccessor& accessor)
  {
    assert(size_t(accessor.componentType) < size_t(AccessorComponentType::Count));
    assert(size_t(accessor.type) < size_t(AccessorType::Count));
    return accessorTypeSize[size_t(accessor.type)] * accessorComponentTypeSize[size_t(accessor.componentType)];
  }
 
  [[nodiscard]] bool getBufferViewData(const GltfModelDefinition& loadData, BufferDataView& dataView, const GltfAccessor& accessor)
  {
    if (loadData.buffer_views.size() <= accessor.bufferView) {
      LOG_ERROR(logger, "%.*s: Illegal accessor buffer view index %u", StringViewFormat(loadData.path), accessor.bufferView);
      return false;
    }
    const GltfBufferView& bufferView = loadData.buffer_views[accessor.bufferView];
 
    if (loadData.buffer_data.size() <= bufferView.buffer) {
      LOG_ERROR(logger, "%.*s: Illegal buffer view buffer index %u", StringViewFormat(loadData.path), bufferView.buffer);
      return false;
    }
    std::span<const uint8_t> buffer = loadData.buffer_data[bufferView.buffer];
 
    size_t byteOffset = size_t(accessor.byteOffset) + bufferView.byteOffset;
    uint32_t stride = bufferView.byteStride != 0u ? bufferView.byteStride : getAccessorTypeSize(accessor);
 
    if (buffer.size() < byteOffset + size_t(stride) * accessor.count) {
      LOG_ERROR(logger, "%.*s: Accessor references outside of buffer (bufferSize=%zd, idx=%zd)",
        StringViewFormat(loadData.path), buffer.size(), byteOffset + size_t(stride) * accessor.count);
      return false;
    }
 
    dataView = {
      .data = buffer.data() + byteOffset,
      .stride = stride,
      .count = accessor.count
    };
 
    return true;
  }
 
  bool loadBone(GltfModelDefinition& definition,
                GltfNode& node,
                Skeleton& skeleton,
                size_t parent_bone,
                const glm::mat4& parent_transform)
  {
    const glm::mat4& localTransform = node.mat;
    const glm::mat4 globalTransform = parent_transform * localTransform;
 
    uint32_t boneIndex = (uint32_t)skeleton.bones.size();
    node.bone_index = boneIndex;
 
    auto& bone = skeleton.bones.emplace_back();
    bone.name = std::to_string(node.node_index) + "_" + node.name;
    bone.parentBone = parent_bone;
    bone.pos = node.pos;
    bone.scale = node.scale;
    bone.rot = node.rot;
    bone.relative = localTransform;
    bone.absolute = globalTransform;
    bone.inverseBindPose = glm::mat4(1.0);
    bone.hasOffset = false;
    bone.used = false;
    bone.animated = false;
 
    skeleton.bonesByName[bone.name] = boneIndex;
 
    for (uint32_t childIndex : node.children) {
      if (!loadBone(definition, definition.nodes[childIndex], skeleton, boneIndex, globalTransform)) {
        return false;
      }
    }
 
    return true;
  }
 
  bool loadJoints(GltfModelDefinition& definition,
      GltfNode& node,
      Skeleton& skeleton,
      MeshoptDecompressor& meshoptDecomp)
  {
      for (uint32_t childIndex : node.children) {
          if (!loadJoints(definition, definition.nodes[childIndex], skeleton, meshoptDecomp)) {
              return false;
          }
      }
 
      if (node.skin != (uint32_t)-1) {
          skeleton.bindPose = glm::inverse(skeleton.bones[node.bone_index].absolute);
          GltfSkin& skin = definition.skins[node.skin];
 
          if (definition.accessors.size() <= size_t(skin.inverseBindMatrices)) {
              return false;
          }
 
          size_t accessorIdx = size_t(skin.inverseBindMatrices);
          GltfAccessor accessor = definition.accessors[accessorIdx];
 
          // Meshopt compressed?
          if (meshoptDecomp.isCompressed(definition, int(accessorIdx))) {
              bool ok = meshoptDecomp.decompress(definition, int(accessorIdx));
              if (!ok) {
                  return false;
              }
          }
 
          BufferDataView dataView;
          if (!getBufferViewData(definition, dataView, accessor)) {
              return false;
          }
 
          size_t i = 0;
          for (uint32_t jointIndex : skin.joints) {
              auto& joint = skeleton.bones[definition.nodes[jointIndex].bone_index];
              joint.inverseBindPose = *reinterpret_cast<const glm::mat4*>(dataView.data + dataView.stride * i++);
              joint.hasOffset = true;
              joint.used = true;
          }
      }
 
      return true;
  }
 
  [[nodiscard]] bool getVertexElement(GltfModelDefinition& loadData, VertexStreamsState& streamsState, VertexStream& vertexStream, const Cogs::StringView& key, const uint32_t accessorIx)
  {
    if (loadData.accessors.size() <= accessorIx) {
      LOG_ERROR(logger, "%.*s: Illegal access index %u", StringViewFormat(loadData.path), accessorIx);
      return false;
    }
    const GltfAccessor& accessor = loadData.accessors[accessorIx];
 
    if (!getBufferViewData(loadData, vertexStream.dataView, accessor)) {
      return false;
    }
 
    // Non-indexed attributes
    // ----------------------
 
    switch (key.hash()) {
    case Cogs::hash("POSITION"):
      if (accessor.type == AccessorType::Vec3 &&
          (accessor.componentType == AccessorComponentType::Float ||
           accessor.componentType == AccessorComponentType::Byte ||
           accessor.componentType == AccessorComponentType::Short ||
           accessor.componentType == AccessorComponentType::UnsignedShort)) {
        streamsState.positionData = vertexStream.dataView;
        streamsState.positionPresent = true;
        streamsState.positionCount = accessor.count;
        vertexStream.semantic = Cogs::ElementSemantic::Position;
        vertexStream.format = Cogs::DataFormat::R32G32B32_FLOAT;
 
        if (accessor.componentType != AccessorComponentType::Float) {
          // The standardshader material only accepts Float3 vertices. We'll therefore convert the data to keep things simple.
          loadData.positionsScratch.push_back(Memory::MemoryBuffer());
          vertexStream.dataView = convertVecBufferToFloats<glm::vec3>(vertexStream.dataView, accessor.componentType, &loadData.positionsScratch.back());
        }
        streamsState.positionData = vertexStream.dataView;
 
        if (accessor.minCount == 3 && accessor.maxCount == 3) {
          if (accessor.componentType == AccessorComponentType::Float) {
            streamsState.bbox.min = glm::make_vec3(accessor.min.s_float);
            streamsState.bbox.max = glm::make_vec3(accessor.max.s_float);
          }
          else if (accessor.componentType == AccessorComponentType::UnsignedShort) {
            streamsState.bbox.min = glm::make_vec3(accessor.min.s_uint);
            streamsState.bbox.max = glm::make_vec3(accessor.max.s_uint);
          }
          else {
            streamsState.bbox.min = glm::make_vec3(accessor.min.s_int);
            streamsState.bbox.max = glm::make_vec3(accessor.max.s_int);
          }
        }
        else {
          LOG_WARNING_ONCE(logger, "%.*s: POSITION attribute has missing or malformed min and max values", StringViewFormat(loadData.path));
          streamsState.bbox.min = glm::vec3(std::numeric_limits<float>::max());
          streamsState.bbox.max = -streamsState.bbox.min;
          for (size_t i = 0; i < streamsState.positionCount; i++) {
            const glm::vec3& p = *(const glm::vec3*)(streamsState.positionData.data + streamsState.positionData.stride * i);
            if (std::isfinite(p.x) && std::isfinite(p.y) && std::isfinite(p.z)) {
              streamsState.bbox.min = min(streamsState.bbox.min, p);
              streamsState.bbox.max = max(streamsState.bbox.max, p);
            }
          }
        }
 
        return true;
      }
      LOG_ERROR(logger, "%.*s: Illegal POSITION accessor type %s of %s", StringViewFormat(loadData.path), accessorTypeName[size_t(accessor.type)], accessorComponentTypeName[size_t(accessor.componentType)]);
      return false;
 
    case Cogs::hash("NORMAL"):
      if (accessor.type == AccessorType::Vec3 &&
          (accessor.componentType == AccessorComponentType::Float ||
           accessor.componentType == AccessorComponentType::Byte ||
           accessor.componentType == AccessorComponentType::Short)) {
        if (accessor.componentType != AccessorComponentType::Float) {
          // The standardshader material only accepts Float3 normals. We'll therefore convert the data to keep things simple.
          loadData.normalsScratch.push_back(Memory::MemoryBuffer());
          vertexStream.dataView = convertVecBufferToFloats<glm::vec3>(vertexStream.dataView, accessor.componentType, &loadData.normalsScratch.back());
        }
 
        streamsState.normalData = vertexStream.dataView;
        streamsState.normalPresent = true;
        vertexStream.semantic = Cogs::ElementSemantic::Normal;
        vertexStream.format = Cogs::DataFormat::R32G32B32_FLOAT;
 
        return true;
      }
      LOG_ERROR(logger, "%.*s: Illegal NORMAL accessor type %s of %s", StringViewFormat(loadData.path), accessorTypeName[size_t(accessor.type)], accessorComponentTypeName[size_t(accessor.componentType)]);
      return false;
 
    case Cogs::hash("TANGENT"):
      if (accessor.type == AccessorType::Vec4 &&
          (accessor.componentType == AccessorComponentType::Float ||
           accessor.componentType == AccessorComponentType::Byte ||
           accessor.componentType == AccessorComponentType::Short)) {
        streamsState.tangentPresent = true;
        vertexStream.semantic = Cogs::ElementSemantic::Tangent;
        if (accessor.componentType != AccessorComponentType::Float) {
          // The standardshader material only accepts Float4 tangents. We'll therefore convert the data to keep things simple.
          loadData.tangentsScratch.push_back(Memory::MemoryBuffer());
          vertexStream.dataView = convertVecBufferToFloats<glm::vec4>(vertexStream.dataView, accessor.componentType, &loadData.tangentsScratch.back());
        }
        vertexStream.format = Cogs::DataFormat::R32G32B32_FLOAT;
 
        return true;
      }
      LOG_ERROR(logger, "%.*s: Illegal TANGENT accessor type %s of %s", StringViewFormat(loadData.path), accessorTypeName[size_t(accessor.type)], accessorComponentTypeName[size_t(accessor.componentType)]);
      return false;
 
    default:
 
      // Indexed attributes
      // ------------------
 
      if (size_t underscore = key.find_first_of('_');
          underscore != Cogs::StringView::NoPosition &&   // There is an underscore
          underscore + 1 < key.length() &&                // There is at least one character after the underscore
          '0' <= key[underscore + 1] &&                   // The character is an digit
          key[underscore + 1] <= '9')
      {
        vertexStream.semanticIndex = 0;
        size_t digit = underscore + 1;
        for (; digit < key.size() && '0' <= key[digit] && key[digit] <= '9'; digit++) {
          vertexStream.semanticIndex = 10 * vertexStream.semanticIndex + uint32_t(key[digit] - '0');
        }
 
        if (digit == key.length()) { // no garbage after last digit
          switch (key.substr(0, underscore).hash()) {
          case Cogs::hash("TEXCOORD"):
            if (vertexStream.semanticIndex == 0) {
              if (accessor.componentType != AccessorComponentType::Float) {
                // The standard-shader material only accepts Float2 texcoords. We'll therefore convert the data to keep things simple.
                loadData.texCoordsScratch.push_back(Memory::MemoryBuffer());
                vertexStream.dataView = convertVecBufferToFloats<glm::vec2>(vertexStream.dataView, accessor.componentType, &loadData.texCoordsScratch.back());
              }
            }
 
            // Pre-calc texture coord transforms from a KHR_texture_transform setting?
            if (loadData.textureTransforms.size()) {
              const TextureTransform& textureTransform = loadData.textureTransforms.back(); // Always use the LAST texture-transform registered.
              float* buf = reinterpret_cast<float*>(const_cast<uint8_t*>(vertexStream.dataView.data));
              size_t num = vertexStream.dataView.count;
              const glm::mat3 translation = glm::mat3(1.0, 0, 0,  0, 1.0, 0,  textureTransform.offset.x, textureTransform.offset.y, 1.0);
              const glm::mat3 rotation = glm::mat3(cos(textureTransform.rotation), sin(textureTransform.rotation), 0,
                                                   -sin(textureTransform.rotation), cos(textureTransform.rotation), 0,
                                                   0, 0, 1.0);
              const glm::mat3 scale = glm::mat3(textureTransform.scale.x, 0, 0,  0, textureTransform.scale.y, 0,  0, 0, 1.0);
              const glm::mat3 xform = translation * rotation * scale;
 
              for (size_t i = 0; i < num; ++i) {
                const glm::vec3 result = xform * glm::vec3(buf[i * 2], buf[i * 2 + 1], 1.0);
                buf[i * 2] = result.x;
                buf[i * 2 + 1] = result.y;
              }
            }
 
            streamsState.texcoordData = vertexStream.dataView;
            streamsState.texcoordStreamCount++;
            vertexStream.semantic = Cogs::ElementSemantic::TextureCoordinate;
            vertexStream.format = Cogs::DataFormat::R32G32_FLOAT;
            return true;
 
          case Cogs::hash("COLOR"):
            streamsState.colorStreamCount++;
            vertexStream.semantic = Cogs::ElementSemantic::Color;
            if (accessor.type == AccessorType::Vec3) {
              switch (accessor.componentType) {
              case AccessorComponentType::Float:         vertexStream.format = Cogs::DataFormat::R32G32B32_FLOAT; return true;
              case AccessorComponentType::UnsignedByte:  vertexStream.format = Cogs::DataFormat::R8G8B8_UNORM;    return true;
              case AccessorComponentType::UnsignedShort: vertexStream.format = Cogs::DataFormat::R16G16B16_UNORM; return true;
              default: break;
              }
            }
            else if (accessor.type == AccessorType::Vec4) {
              switch (accessor.componentType) {
              case AccessorComponentType::Float:         vertexStream.format = Cogs::DataFormat::R32G32B32A32_FLOAT; return true;
              case AccessorComponentType::UnsignedByte:  vertexStream.format = Cogs::DataFormat::R8G8B8A8_UNORM;     return true;
              case AccessorComponentType::UnsignedShort: vertexStream.format = Cogs::DataFormat::R16G16B16A16_UNORM; return true;
              default: break;
              }
            }
            LOG_ERROR(logger, "%.*s: Illegal COLOR accessor type %s of %s", StringViewFormat(loadData.path), accessorTypeName[size_t(accessor.type)], accessorComponentTypeName[size_t(accessor.componentType)]);
            return false;
 
          case Cogs::hash("JOINTS"):
            if (vertexStream.semanticIndex == 0) {  // We only support one set of joints, at least for now
              streamsState.jointsStreamCount = 1;
              vertexStream.semantic = Cogs::ElementSemantic::Color;
              vertexStream.semanticIndex = 4;
              if (accessor.type == AccessorType::Vec4) {
                switch (accessor.componentType) {
                case AccessorComponentType::UnsignedByte:  vertexStream.format = Cogs::DataFormat::R8G8B8A8_UINT;     return true;
                case AccessorComponentType::UnsignedShort: vertexStream.format = Cogs::DataFormat::R16G16B16A16_UINT; return true;
                case AccessorComponentType::Float: vertexStream.format = Cogs::DataFormat::R32G32B32A32_FLOAT; return true;
                default: break;
                }
              }
              LOG_ERROR(logger, "%.*s: Illegal JOINTS accessor type %s of %s", StringViewFormat(loadData.path), accessorTypeName[size_t(accessor.type)], accessorComponentTypeName[size_t(accessor.componentType)]);
              return false;
            }
            break;
 
          case Cogs::hash("WEIGHTS"):
            if (vertexStream.semanticIndex == 0) {  // We only support one set of weights, at least for now
              vertexStream.semantic = Cogs::ElementSemantic::Color;
              vertexStream.semanticIndex = 5;
              if (accessor.type == AccessorType::Vec4) {
                switch (accessor.componentType) {
                case AccessorComponentType::Float:         vertexStream.format = Cogs::DataFormat::R32G32B32A32_FLOAT; return true;
                case AccessorComponentType::UnsignedByte:  vertexStream.format = Cogs::DataFormat::R8G8B8A8_UNORM;     return true;
                case AccessorComponentType::UnsignedShort: vertexStream.format = Cogs::DataFormat::R16G16B16A16_UNORM; return true;
                default: break;
                }
              }
              LOG_ERROR(logger, "%.*s: Illegal WEIGHTS accessor type %s of %s", StringViewFormat(loadData.path), accessorTypeName[size_t(accessor.type)], accessorComponentTypeName[size_t(accessor.componentType)]);
              return false;
            }
            break;
 
          default:
            break;
          }
        }
      }
      break;
    }
 
    LOG_WARNING_ONCE(logger, "Unrecognized attribute semantic %.*s", StringViewFormat(key));
    return false;
  }
 
  [[nodiscard]] bool getVertexAttributes(GltfModelDefinition& loadData, VertexStreamsState& streamsState, std::vector<VertexStream>& vertexStreams, const Object& attributeObject, MeshoptDecompressor& meshoptDecomp)
  {
    for (const auto& attributeIt : attributeObject) {
      // Retrieve accessor
      uint32_t accessorIx = 0;
      if (!getUint(loadData, accessorIx, attributeIt)) {
        return false;
      }
 
      // Meshopt compressed attribute?
      if (meshoptDecomp.isCompressed(loadData, accessorIx)) {
        meshoptDecomp.decompress(loadData, accessorIx);
      }
 
      // Retrieve vertex specification
      VertexStream vertexStream;
      if (getVertexElement(loadData, streamsState, vertexStream, toView(attributeIt.name), accessorIx)) {
        vertexStreams.push_back(vertexStream);
      }
    }
 
    if (!streamsState.positionPresent) {
      LOG_ERROR(logger, "%.*s: Primitive has no POSITION attribute", StringViewFormat(loadData.path));
      return false;
    }
 
    for (const auto& stream : vertexStreams) {
      if (stream.dataView.count != streamsState.positionCount) {
        LOG_ERROR(logger, "%.*s: Primitive has attributes with variable counts", StringViewFormat(loadData.path));
        return false;
      }
    }
 
    return true;
  }
 
  [[nodiscard]] bool generateVertexTangents(GltfModelDefinition& loadData, VertexStreamsState& streamsState, std::vector<VertexStream>& vertexStreams, Cogs::PrimitiveType::EPrimitiveType primitiveType, bool clockwise)
  {
    if (primitiveType != Cogs::PrimitiveType::TriangleList) {
      LOG_ERROR(logger, "%.*s: Vertex tangent generator only supports triangle lists (type is %d)", StringViewFormat(loadData.path), primitiveType);
      return false;
    }
    assert(streamsState.positionPresent);
    assert(streamsState.normalPresent);
    assert(streamsState.texcoordStreamCount);
 
    const size_t byteSize = sizeof(glm::vec3) * streamsState.positionCount;
 
    loadData.tangentsScratch.push_back(Memory::MemoryBuffer());
    Memory::MemoryBuffer * memBuf = &loadData.tangentsScratch.back();
    memBuf->resize(byteSize);
    glm::vec3* tangents = (glm::vec3*) memBuf->data();
    std::memset(static_cast<void*>(tangents), 0, byteSize);
 
    size_t count = streamsState.indexType != AccessorComponentType::None ? streamsState.indexData.count : streamsState.positionCount;
    for (size_t i = 0; i + 2 < count; i += 3) {
      size_t ix[3] = { 0,0,0 };
      switch (streamsState.indexType) {
      case AccessorComponentType::None:          for (size_t k = 0; k < 3; k++) { ix[k] = i + k; } break;
      case AccessorComponentType::UnsignedByte:  for (size_t k = 0; k < 3; k++) { ix[k] = *(streamsState.indexData.data + streamsState.indexData.stride * (i + k)); } break;
      case AccessorComponentType::UnsignedShort: for (size_t k = 0; k < 3; k++) { ix[k] = *(const uint16_t*)(streamsState.indexData.data + streamsState.indexData.stride * (i + k)); } break;
      case AccessorComponentType::UnsignedInt:   for (size_t k = 0; k < 3; k++) { ix[k] = *(const uint32_t*)(streamsState.indexData.data + streamsState.indexData.stride * (i + k)); } break;
      default: assert(false); return false;
      }
 
      glm::vec3 a = *(const glm::vec3*)(streamsState.positionData.data + streamsState.positionData.stride * ix[0]);
      glm::vec3 b = *(const glm::vec3*)(streamsState.positionData.data + streamsState.positionData.stride * ix[1]);
      glm::vec3 c = *(const glm::vec3*)(streamsState.positionData.data + streamsState.positionData.stride * ix[2]);
      glm::vec2 ta = *(const glm::vec2*)(streamsState.texcoordData.data + streamsState.texcoordData.stride * ix[0]);
      glm::vec2 tb = *(const glm::vec2*)(streamsState.texcoordData.data + streamsState.texcoordData.stride * ix[1]);
      glm::vec2 tc = *(const glm::vec2*)(streamsState.texcoordData.data + streamsState.texcoordData.stride * ix[2]);
 
      glm::vec2 u0, u1;
      glm::vec3 v0, v1;
      if (!clockwise) {
        u0 = tb - ta;
        u1 = tc - ta;
        v0 = b - a;
        v1 = c - a;
      }
      else {
        u0 = tc - ta;
        u1 = tb - ta;
        v0 = c - a;
        v1 = b - a;
      }
 
      float den = 1.f / (u0.x * u1.y - u0.y * u1.x);
      glm::vec3 t0 = u1.y * den * v0 - u0.y * den * v1;
 
      tangents[ix[0]] += t0;
      tangents[ix[1]] += t0;
      tangents[ix[2]] += t0;
    }
 
    for (size_t i = 0; i < streamsState.positionCount; i++) {
      const glm::vec3 normal = *(const glm::vec3*)(streamsState.normalData.data + streamsState.normalData.stride * i);
      tangents[i] = glm::normalize(tangents[i] - glm::dot(normal, tangents[i]) * normal);
    }
 
    vertexStreams.push_back(VertexStream{
      .dataView = {
        .data = (const uint8_t*) memBuf->data(),
        .stride = sizeof(glm::vec3),
        .count = streamsState.positionCount
      },
      .format = Cogs::DataFormat::R32G32B32_FLOAT,
      .semantic = Cogs::ElementSemantic::Tangent,
      .semanticIndex = 0
    });
 
    return true;
  }
 
  [[nodiscard]] bool generateVertexNormals(GltfModelDefinition& loadData, VertexStreamsState& streamsState, std::vector<VertexStream>& vertexStreams, Cogs::PrimitiveType::EPrimitiveType primitiveType, bool clockwise)
  {
    if (primitiveType != Cogs::PrimitiveType::TriangleList) {
      LOG_ERROR(logger, "%.*s: Vertex normal generator only supports triangle lists", StringViewFormat(loadData.path));
      return false;
    }
    assert(streamsState.positionPresent);
 
    const size_t byteSize = sizeof(glm::vec3) * streamsState.positionCount;
    loadData.normalsScratch.push_back(Memory::MemoryBuffer());
    Memory::MemoryBuffer* memBuf = &loadData.normalsScratch.back();
 
    memBuf->resize(byteSize);
    glm::vec3* normals = (glm::vec3*) memBuf->data();
    std::memset(static_cast<void*>(normals), 0, byteSize);
 
    size_t count = streamsState.indexSize ? streamsState.indexData.count : streamsState.positionCount;
    for (size_t i = 0; i + 2 < count; i += 3) {
      size_t ix[3] = { 0,0,0 };
      switch (streamsState.indexSize) {
      case 0: for (size_t k = 0; k < 3; k++) { ix[k] = i + k; } break;
      case 1: for (size_t k = 0; k < 3; k++) { ix[k] = *(streamsState.indexData.data + streamsState.indexData.stride * (i + k)); } break;
      case 2: for (size_t k = 0; k < 3; k++) { ix[k] = *(const uint16_t*)(streamsState.indexData.data + streamsState.indexData.stride * (i + k)); } break;
      case 4: for (size_t k = 0; k < 3; k++) { ix[k] = *(const uint32_t*)(streamsState.indexData.data + streamsState.indexData.stride * (i + k)); } break;
      default: assert(false); return false;
      }
      glm::vec3 a = *(const glm::vec3*)(streamsState.positionData.data + streamsState.positionData.stride * ix[0]);
      glm::vec3 b = *(const glm::vec3*)(streamsState.positionData.data + streamsState.positionData.stride * ix[1]);
      glm::vec3 c = *(const glm::vec3*)(streamsState.positionData.data + streamsState.positionData.stride * ix[2]);
 
      const glm::vec3 l1 = clockwise ? a - b : b - a;
      const glm::vec3 l2 = clockwise ? a - c : c - a;
      glm::vec3 n = glm::cross(l1, l2);
 
      if (glm::length(n) <= 0.0) {
        LOG_WARNING_ONCE(logger, "Calculated normal is not valid (normalIdx=%zu)", i);
        n = glm::vec3(1, 0, 0);
      }
 
      normals[ix[0]] += n;
      normals[ix[1]] += n;
      normals[ix[2]] += n;
    }
 
    for (size_t i = 0; i < streamsState.positionCount; i++) {
      normals[i] = glm::normalize(normals[i]);
    }
 
    vertexStreams.push_back(VertexStream{
      .dataView = {
        .data = (const uint8_t*) normals,
        .stride = sizeof(glm::vec3),
        .count = streamsState.positionCount
      },
      .format = Cogs::DataFormat::R32G32B32_FLOAT,  // Let the shader add .w=1
      .semantic = Cogs::ElementSemantic::Normal,
      .semanticIndex = 0,
    });
 
    return true;
  }
 
  [[nodiscard]] bool setMeshIndices(GltfModelDefinition& loadData, MeshManager::ResourceProxy& mesh, VertexStreamsState& streamsState)
  {
    uint32_t dstStride = 0;
    switch (streamsState.indexType) {
    // NOTE: We'll be using stride=2 for bytes as Cogs.Rendering does not support strides of 1.
    case AccessorComponentType::UnsignedByte:  dstStride = 2; streamsState.indexSize = 1; break;
    case AccessorComponentType::UnsignedShort: dstStride = 2; streamsState.indexSize = dstStride; break;
    case AccessorComponentType::UnsignedInt:   dstStride = 4; streamsState.indexSize = dstStride; break;
    default:
      LOG_ERROR(logger, "%.*s: Illegal index data component type %s", StringViewFormat(loadData.path), accessorComponentTypeName[size_t(streamsState.indexType)]);
      return false;
    }
 
    if (uint8_t* dst = mesh->mapStream(VertexDataType::Indexes, 0, streamsState.indexData.count, dstStride, true); dst) {
      switch (streamsState.indexType) {
      case AccessorComponentType::UnsignedByte:  stridedCopy<1>(dst, 2, streamsState.indexData.data, streamsState.indexData.stride, streamsState.indexData.count); break;
      case AccessorComponentType::UnsignedShort: stridedCopy<2>(dst, 2, streamsState.indexData.data, streamsState.indexData.stride, streamsState.indexData.count); break;
      case AccessorComponentType::UnsignedInt:   stridedCopy<4>(dst, 4, streamsState.indexData.data, streamsState.indexData.stride, streamsState.indexData.count); break;
      default: assert(false); break;
      }
      mesh->unmap(VertexDataType::Indexes);
    }
    mesh->setMeshFlag(MeshFlags::Indexed);
    mesh->setMeshFlag(MeshFlags::IndexesChanged);
    mesh->setCount(streamsState.indexData.count);
    return true;
  }
 
  [[nodiscard]] bool setVertexAttributes(GltfModelDefinition& loadData, MeshManager::ResourceProxy& mesh, const VertexStreamsState& streamsState, std::vector<VertexStream>& vertexStreams)
  {
    // Build vertex format
    Cogs::VertexFormatHandle vertexFormat;
 
    for (VertexStream& vertexStream : vertexStreams) {
      const Cogs::FormatInfo* formatInfo = Cogs::getFormatInfo(vertexStream.format);
      assert(formatInfo);
      assert(formatInfo->blockSize);
      vertexStream.formatSize = formatInfo->blockSize;
    }
 
    size_t offset = 0;
    std::vector<Cogs::VertexElement> vertexElements;
    for (VertexStream& vertexStream : vertexStreams) {
      offset = (offset + 3) & ~3;
      vertexStream.offset = offset;
      vertexElements.push_back(Cogs::VertexElement{
        .offset = uint16_t(offset),
        .format = vertexStream.format,
        .semantic = vertexStream.semantic,
        .semanticIndex = uint16_t(vertexStream.semanticIndex),
        .inputType = Cogs::InputType::VertexData,
        .instanceStep = 0
                               });
      offset += vertexStream.formatSize;
    }
 
    vertexFormat = Cogs::VertexFormats::createVertexFormat(vertexElements.data(), vertexElements.size());
    if (!HandleIsValid(vertexFormat)) {
      LOG_ERROR(logger, "%.*s: Failed to create vertex format with %zu elements", StringViewFormat(loadData.path), vertexElements.size());
      return false;
    }
 
    // Store data
    size_t stride = Cogs::getSize(vertexFormat);
    if (uint8_t* base = mesh->mapStream(VertexDataType::Interleaved0, vertexFormat, 0, streamsState.positionCount, stride, true)) {
      for (const VertexStream& vertexStream : vertexStreams) {
        uint8_t* dst = base + vertexStream.offset;
        switch (vertexStream.format) {
        case Cogs::DataFormat::R32G32B32A32_FLOAT:  // 4*4 = 16
          assert(vertexStream.formatSize == 16);
          stridedCopy<16>(dst, stride, vertexStream.dataView.data, vertexStream.dataView.stride, streamsState.positionCount);
          break;
 
        case Cogs::DataFormat::R32G32B32_FLOAT:     // 3*4 = 12
          assert(vertexStream.formatSize == 12);
          stridedCopy<12>(dst, stride, vertexStream.dataView.data, vertexStream.dataView.stride, streamsState.positionCount);
          break;
 
        case Cogs::DataFormat::R32G32_FLOAT:        // 2*4 = 8
        case Cogs::DataFormat::R16G16B16A16_UNORM:  // 4*2 = 8
        case Cogs::DataFormat::R16G16B16A16_UINT:   // 4*2 = 8
          assert(vertexStream.formatSize == 8);
          stridedCopy<8>(dst, stride, vertexStream.dataView.data, vertexStream.dataView.stride, streamsState.positionCount);
          break;
 
        case Cogs::DataFormat::R16G16B16_UNORM:     // 3*2 = 6
        case Cogs::DataFormat::R16G16B16_UINT:
        case Cogs::DataFormat::R16G16B16_SINT:
        case Cogs::DataFormat::R16G16B16_SNORM:
          assert(vertexStream.formatSize == 6);
          stridedCopy<6>(dst, stride, vertexStream.dataView.data, vertexStream.dataView.stride, streamsState.positionCount);
          break;
 
        case Cogs::DataFormat::R16G16_UNORM:        // 2*2 = 4
        case Cogs::DataFormat::R16G16_UINT:
        case Cogs::DataFormat::R16G16_SNORM:
        case Cogs::DataFormat::R16G16_SINT:
        case Cogs::DataFormat::R8G8B8A8_UNORM:      // 4*1 = 4
        case Cogs::DataFormat::R8G8B8A8_UINT:
          assert(vertexStream.formatSize == 4);
          stridedCopy<4>(dst, stride, vertexStream.dataView.data, vertexStream.dataView.stride, streamsState.positionCount);
          break;
 
        case Cogs::DataFormat::R8G8B8_UNORM:        // 3*1 = 3
        case Cogs::DataFormat::R8G8B8_UINT:
        case Cogs::DataFormat::R8G8B8_SINT:
        case Cogs::DataFormat::R8G8B8_SNORM:
          assert(vertexStream.formatSize == 3);
          stridedCopy<3>(dst, stride, vertexStream.dataView.data, vertexStream.dataView.stride, streamsState.positionCount);
          break;
 
        case Cogs::DataFormat::R8G8_UNORM:          // 2*1 = 2
          assert(vertexStream.formatSize == 3);
          stridedCopy<2>(dst, stride, vertexStream.dataView.data, vertexStream.dataView.stride, streamsState.positionCount);
          break;
 
        default:
          assert(false && "Unhandled DataFormat");
          break;
        }
      }
      mesh->unmap(VertexDataType::Interleaved0);
    }
    return true;
  }
 
  [[nodiscard]] bool buildPrimitiveMesh(GltfModelDefinition& loadData, ModelMeshInstance& modelMeshInstance, Model& model, const Object& primitiveObject, int32_t skinIx, bool clockwise, MeshoptDecompressor & meshoptDecomp)
  {
    VertexStreamsState streamsState;
    std::vector<VertexStream> vertexStreams;
 
    // Check if unlit
    bool needsNormals = true;
    if (auto materialIt = primitiveObject.FindMember("material"); materialIt != primitiveObject.MemberEnd()) {
      uint32_t materialIx = 0;
      if (!getUint(loadData, materialIx, *materialIt)) {
        LOG_ERROR(logger, "The 'meshes.primitives.material' is not an integer");
        return false;
      }
      if (materialIx >= 0) {
        const Object& materialObject = loadData.materialsArray[materialIx];
        if (materialObject.HasMember("extensions") && materialObject["extensions"].HasMember("KHR_materials_unlit")) {
          needsNormals = false;
        }
      }
    }
 
    // Process attributes
    bool useDracoDecompression = false;
    DracoMeshDecompressor draco;
 
    // Is this mesh using the DRACO extension?
    if (primitiveObject.HasMember("extensions") && primitiveObject["extensions"].HasMember("KHR_draco_mesh_compression")) {
      auto extSection = primitiveObject["extensions"].GetObject();
      auto dracoSection = extSection["KHR_draco_mesh_compression"].GetObject();
      draco.initAttributes(dracoSection);
      useDracoDecompression = true;
    }
 
    if (const auto& attributesIt = primitiveObject.FindMember("attributes"); attributesIt != primitiveObject.MemberEnd()) {
      if (!checkIsObject(loadData, *attributesIt)) {
        return false;
      }
 
      if (useDracoDecompression) {
        if (!draco.decompress(loadData, streamsState, vertexStreams, attributesIt->value.GetObject(), !needsNormals)) {
          return false;
        }
      }
      else {
        if (!getVertexAttributes(loadData, streamsState, vertexStreams, attributesIt->value.GetObject(), meshoptDecomp)) {
          return false;
        }
      }
    }
    else {
      LOG_ERROR(logger, "%.*s: Primitive has no attribute property", StringViewFormat(loadData.path));
      return false;
    }
 
    // Process indices
    bool isIndexed = false;
    uint32_t indicesAccessorIx = 0;
 
    if (useDracoDecompression) {
      isIndexed = true; // All index data has been set by the draco-decompressor
    }
    else {
      if (auto indicesIt = primitiveObject.FindMember("indices"); indicesIt != primitiveObject.MemberEnd()) {
        if (!getUint(loadData, indicesAccessorIx, *indicesIt)) {
          LOG_ERROR(logger, "The 'meshes.primitives.indices' is not an integer");
          return false;
        }
 
        if (loadData.accessors.size() <= indicesAccessorIx) {
          LOG_ERROR(logger, "%.*s: Illegal accessor index %u", StringViewFormat(loadData.path), indicesAccessorIx);
          return false;
        }
 
        const GltfAccessor& accessor = loadData.accessors[indicesAccessorIx];
        streamsState.indexType = accessor.componentType;
 
        if (meshoptDecomp.isCompressed(loadData, indicesAccessorIx)) {
          bool ok = meshoptDecomp.decompress(loadData, indicesAccessorIx);
          if (!ok) {
            return false;
          }
        }
 
        if (!getBufferViewData(loadData, streamsState.indexData, accessor)) {
          return false;
        }
 
        isIndexed = true;
      }
    }
 
    Cogs::PrimitiveType::EPrimitiveType primitiveType = Cogs::PrimitiveType::TriangleList;
    if (auto modeIt = primitiveObject.FindMember("mode"); modeIt != primitiveObject.MemberEnd()) {
      uint32_t mode = 0;
      if (!getUint(loadData, mode, *modeIt)) {
        return false;
      }
 
      switch (mode) {
      case 0: primitiveType = Cogs::PrimitiveType::PointList; break;
      case 1: primitiveType = Cogs::PrimitiveType::LineList; break;
      case 3: primitiveType = Cogs::PrimitiveType::LineStrip; break;
      case 4: primitiveType = Cogs::PrimitiveType::TriangleList; break;
      case 5: primitiveType = Cogs::PrimitiveType::TriangleStrip; break;
      case 2: LOG_ERROR(logger, "%.*s: Unsupported primitive mode 2: LINE_LOOP", StringViewFormat(loadData.path)); return false;
      case 6: LOG_ERROR(logger, "%.*s: Unsupported primitive mode 6: TRIANGLE_FAN", StringViewFormat(loadData.path)); return false;
      default: LOG_ERROR(logger, "%.*s: Illegal primitive mode %u", StringViewFormat(loadData.path), mode); return false;
      }
    }
 
    // targets
    // -------
    if (auto targetsIt = primitiveObject.FindMember("targets"); targetsIt != primitiveObject.MemberEnd()) {
      if (!checkIsArray(loadData, *targetsIt)) {
        return false;
      }
      if (!targetsIt->value.GetArray().Empty()) {
        // Not implemented yet.
        LOG_WARNING_ONCE(logger, "%.*s: Morph targets not implemented yet, ignoring.", StringViewFormat(loadData.path));
      }
    }
 
    // Process materials.
    bool isSkinned = streamsState.jointsStreamCount != 0;
    bool albedoPerVertex = streamsState.colorStreamCount != 0;
    CachedModelMaterial* modelMaterial = nullptr;
    if (auto materialIt = primitiveObject.FindMember("material"); materialIt != primitiveObject.MemberEnd()) {
      uint32_t materialIx = 0;
      if (!getUint(loadData, materialIx, *materialIt)) {
        LOG_ERROR(logger, "The 'meshes.primitives.material' is not an integer");
        return false;
      }
      if (!getMaterialHandle(loadData, model, modelMaterial, materialIx, isSkinned, albedoPerVertex, false)) {
        return false;
      }
    }
    else {
      if (!getMaterialHandle(loadData, model, modelMaterial, -1, isSkinned, albedoPerVertex, false)) {
        return false;
      }
    }
    assert(modelMaterial);
    modelMeshInstance.materialIx = modelMaterial->modelMaterialIx;
 
    // Handle missing vertex data
    if (streamsState.texcoordStreamCount < modelMaterial->texCoordSets) {
      LOG_ERROR(logger, "%.*s: Material requires texture coordinates, something which the mesh doesn't have", StringViewFormat(loadData.path));
      return false;
    }
 
    // Handle missing normals
    if (modelMaterial->needsNormals && !streamsState.normalPresent) {
      if (!generateVertexNormals(loadData, streamsState, vertexStreams, primitiveType, clockwise)) {
        return false;
      }
    }
 
    // Handle missing tangents
    if (modelMaterial->needsTangents && !streamsState.tangentPresent) {
      if (!generateVertexTangents(loadData, streamsState, vertexStreams, primitiveType, clockwise)) {
        return false;
      }
    }
 
    // Optionally remove unused streams
    if (loadData.optimizationLevel >= 1) {
      std::vector<VertexStream> culledVertexStreams;
 
      for (auto& stream : vertexStreams) {
        bool keep = false;
        switch (stream.semantic) {
        case Cogs::ElementSemantic::Position:
          keep = stream.semanticIndex == 0;
          break;
        case Cogs::ElementSemantic::Normal:
          keep = modelMaterial->needsNormals ? stream.semanticIndex == 0 : false;          
          break;
        case Cogs::ElementSemantic::Color:
          if (stream.semanticIndex == 4 || stream.semanticIndex == 5) {
            keep = isSkinned;
          }
          else {
            keep = albedoPerVertex && stream.semanticIndex == 0;
          }
          break;
        case Cogs::ElementSemantic::TextureCoordinate:
          keep = stream.semanticIndex < modelMaterial->texCoordSets;
          break;
        case Cogs::ElementSemantic::Tangent:
          keep = stream.semanticIndex == 0;
          break;
        default:
          break;
        }
        if (keep) {
          culledVertexStreams.emplace_back(stream);
        }
        else {
          debugMessageOnce(loadData, "Culled unused vertex stream with semantic=%u:%u", unsigned(stream.semantic), stream.semanticIndex);
        }
      }
      vertexStreams = std::move(culledVertexStreams);
    }
 
    { // Sort vertex streams
      size_t n = 0;
      size_t N = vertexStreams.size();
      std::vector<VertexStream> sortedStreams(N);
      for (const auto& stream : vertexStreams) {
        size_t i = n++;
        while(i && (
          (unsigned(stream.semantic) < unsigned(sortedStreams[i - 1].semantic)) ||
          ((unsigned(stream.semantic) == unsigned(sortedStreams[i - 1].semantic) && (stream.semanticIndex < sortedStreams[i - 1].semanticIndex)))))
        {
          sortedStreams[i] = sortedStreams[i - 1];
          --i;
        }
        sortedStreams[i] = stream;
      }
      vertexStreams = std::move(sortedStreams);
    }
 
    // Calculate mesh hash. Active vertex streams is dependent on material,
    // so we hash those specifically, for indices the accessor index should
    // be sufficient
    size_t meshHash = Cogs::hashSequence(skinIx,
                                         primitiveType,
                                         clockwise ? uint32_t(1) : uint32_t(0),
                                         isIndexed ? uint32_t(~0) : indicesAccessorIx);
    for (const VertexStream& vertexStream : vertexStreams) {
      meshHash = hash(vertexStream, meshHash);
    }
 
    if (auto it = loadData.modelMeshCache.find(meshHash); it != loadData.modelMeshCache.end()) {
      debugMessageOnce(loadData, "Found duplicate primitive description, recycling mesh");
      modelMeshInstance.mesh = it->second;
    }
    else {
      // Create mesh
      MeshManager::ResourceProxy mesh = loadData.context->meshManager->createLocked();
      modelMeshInstance.mesh.meshIx = uint32_t(model.meshes.size());
      model.meshes.push_back(mesh.getHandle());
      if (!setVertexAttributes(loadData, mesh, streamsState, vertexStreams)) {
        return false;
      }
 
      if (clockwise) {
        mesh->setMeshFlag(MeshFlags::ClockwiseWinding);
      }
 
      if (isSkinned) {
        mesh->setMeshFlag(MeshFlags::Skinned);
      }
 
      mesh->primitiveType = primitiveType;
      mesh->setBounds(streamsState.bbox);
      modelMeshInstance.mesh.bboxIx = uint32_t(model.bounds.size());
      model.bounds.push_back(streamsState.bbox);
 
      if (isIndexed) {
        if (!setMeshIndices(loadData, mesh, streamsState)) {
          return false;
        }
      }
      else {
        mesh->setCount(streamsState.positionCount);
      }
      modelMeshInstance.mesh.vertexCount = mesh->getCount();
 
      // Skin
      // ----
      if (skinIx != -1) { // Assume check as been done when read
        assert(size_t(skinIx) < loadData.skins.size());
        const GltfSkin& skin = loadData.skins[skinIx];
        size_t count = skin.joints.size();
        if (kMaxBones < count) {
          LOG_WARNING_ONCE(logger, "%.*s: Unable to handle bone count %zu over %zu", StringViewFormat(loadData.path), count, kMaxBones);
          count = kMaxBones;
        }
 
        std::span<uint32_t> poseIndexes = mesh->mapPoseIndexes(static_cast<uint32_t>(count));
        for (size_t i = 0; i < count; i++) {
          uint32_t jointIx = skin.joints[i];
          poseIndexes[i] = loadData.nodes[jointIx].bone_index;
        }
      }
 
      loadData.modelMeshCache[meshHash] = modelMeshInstance.mesh;
    }
 
    return true;
  }
 
  [[nodiscard]] bool buildMeshes(GltfModelDefinition& loadData, std::vector<ModelMeshInstance>& modelMeshInstances, Model& model, int32_t skinIx, int32_t gltfMeshIx, bool clockwise, MeshoptDecompressor & meshoptDecomp)
  {
    if (loadData.meshesArray.size() < size_t(gltfMeshIx)) {
      LOG_ERROR(logger, "%.*s: Illegal gltf mesh index %u", StringViewFormat(loadData.path), gltfMeshIx);
      return false;
    }
 
    const Object& meshObject = loadData.meshesArray[gltfMeshIx];
 
    if (auto primitivesIt = meshObject.FindMember("primitives"); primitivesIt != meshObject.MemberEnd()) {
      if (!checkIsArray(loadData, *primitivesIt)) {
        return false;
      }
 
      const Array& primitivesArray = primitivesIt->value.GetArray();
      for (auto& primitiveItem : primitivesArray) {
        if (!checkIsObject(loadData, "mesh primitive item", primitiveItem)) {
          return false;
        }
        if (!buildPrimitiveMesh(loadData, modelMeshInstances.emplace_back(), model, primitiveItem.GetObject(), skinIx, clockwise, meshoptDecomp)) {
          return false;
        }
      }
    }
    else {
      LOG_ERROR(logger, "%.*s: Mesh %u has no primitives property", StringViewFormat(loadData.path), gltfMeshIx);
      return false;
    }
 
    return true;
  }
 
  bool loadNode(Context* context,
                GltfModelDefinition& definition,
                GltfNode& node,
                Model& model,
                uint32_t parent_part,
                const glm::mat4& parent_transform,
                MeshoptDecompressor & meshoptDecomp)
  {
    const bool clockwise = glm::determinant(node.mat) < 0.0f;
    const glm::mat4& localTransform = node.mat;
    const glm::mat4 globalTransform = parent_transform * localTransform;
 
    std::string nodeName = std::to_string(node.node_index) + "_" + node.name;
    uint32_t partIndex = (uint32_t)model.parts.size();
    node.part_index = partIndex;
 
    ModelPart& nodePart = model.parts.emplace_back();
    nodePart.parentIndex = parent_part;
    model.setPartTransform(nodePart, localTransform);
    model.setPartName(nodePart, nodeName);
 
    if (node.mesh != (uint32_t)-1) {
      std::vector<ModelMeshInstance> meshes;
      if (!buildMeshes(definition, meshes, model, node.skin, node.mesh, clockwise, meshoptDecomp)) {
        return false;
      }
 
      // If it is just a single mesh, we attach the mesh directly to this node
      if (meshes.size() == 1) {
        nodePart.meshIndex = meshes[0].mesh.meshIx;
        nodePart.materialIndex = meshes[0].materialIx;
        nodePart.boundsIndex = meshes[0].mesh.bboxIx;
        nodePart.vertexCount = meshes[0].mesh.vertexCount;
      }
      else {
        // If there are multiple meshes, we create a child part for each mesh
        for (auto& instance : meshes) {
          ModelPart& part = model.parts.emplace_back();
          part.parentIndex = partIndex;
          part.meshIndex = instance.mesh.meshIx;
          part.materialIndex = instance.materialIx;
          part.boundsIndex = instance.mesh.bboxIx;
          part.vertexCount = instance.mesh.vertexCount;
        }
      }
    }
 
    for (uint32_t child_index : node.children) {
      if (!loadNode(context, definition, definition.nodes[child_index], model, partIndex, globalTransform, meshoptDecomp)) {
        return false;
      }
    }
 
    return true;
  }
 
  bool loadAnimation(Context* context, GltfModelDefinition& definition, Model& model, MeshoptDecompressor& meshoptDecomp)
  {
    if (definition.animations.size()) model.animation = context->animationManager->create();
 
    auto& animation = *model.animation.resolve();
    auto& skeleton = model.skeleton;
 
    for (auto& animationValue : definition.animations) {
      auto& clip = animation.clips.emplace_back();
 
      clip.name = animationValue.name;
      clip.duration = 0.0f;
      clip.resolution = 1.0f;
 
      uint32_t prev_node = (decltype(prev_node))-1;
      for (uint32_t i = 0; i < animationValue.channels.size(); i++) {
        GltfChannel& channel = animationValue.channels[i];
        GltfSampler& sampler = animationValue.samplers[channel.sampler];
        uint32_t nodeIndex = channel.node;
        GltfNode& node = definition.nodes[nodeIndex];
        uint32_t boneIndex = node.bone_index;
 
        if (sampler.interpolation != "" && sampler.interpolation != "LINEAR")  // TODO
          LOG_ERROR(logger, "Unable to handle animation interpolation %s", sampler.interpolation.c_str());
 
        auto& inputAccessor = definition.accessors[sampler.input];
 
        // Meshopt compressed?
        if (meshoptDecomp.isCompressed(definition, sampler.input)) {
          bool ok = meshoptDecomp.decompress(definition, sampler.input);
          if (!ok) {
            return false;
          }
        }
 
        BufferDataView dataView;
        if (!getBufferViewData(definition, dataView, inputAccessor)) {
          return false;
        }
 
        if (!dataView.data || !dataView.count) {
          return false;
        }
 
        float t_max = inputAccessor.max.s_float[0];
        //float t_min = input_accessor.min.s_float[0];
        clip.duration = std::max(t_max, clip.duration);
 
        if (prev_node != nodeIndex) {
          clip.tracks.push_back({});
        }
        prev_node = nodeIndex;
        auto& track = clip.tracks.back();
        track.boneIndex = boneIndex;
 
        skeleton.bones[boneIndex].animated = true;
 
        auto getTime = [](uint32_t i, const uint8_t* iData, const size_t iStride) {
          return *reinterpret_cast<const float*>(iData + iStride * i);
        };
 
        if (definition.accessors.size() <= sampler.output) {
          return false;
        }
 
        const GltfAccessor& outputAccessor = definition.accessors[sampler.output];
 
        // Meshopt compressed? Not supported yet.
        if (meshoptDecomp.isCompressed(definition, sampler.output)) {
          bool ok = meshoptDecomp.decompress(definition, sampler.output);
          if (!ok) {
            return false;
          }
        }
 
        BufferDataView oDataView;
        if (!getBufferViewData(definition, oDataView, outputAccessor)) {
          return false;
        }
 
        if (channel.path == "translation") {
          assert(outputAccessor.type == AccessorType::Vec3);
          track.translations.resize(dataView.count);
 
          for (uint32_t j = 0; j < dataView.count; j++) {
            const float time = getTime(j, dataView.data, dataView.stride);
            glm::vec3 translation = *reinterpret_cast<const glm::vec3*>(oDataView.data + oDataView.stride * j);
            track.translations[j] = TranslationKey{ time, translation };
          }
        }
        else if (channel.path == "scale") {
          assert(outputAccessor.type == AccessorType::Vec3);
          track.scales.resize(dataView.count);
 
          for (uint32_t j = 0; j < dataView.count; j++) {
            const float time = getTime(j, dataView.data, dataView.stride);
            glm::vec3 scale = *reinterpret_cast<const glm::vec3*>(oDataView.data + oDataView.stride * j);
            track.scales[j] = ScaleKey{ time, scale };
          }
        }
        else if (channel.path == "rotation") {
          assert(outputAccessor.type == AccessorType::Vec4);
          track.rotations.resize(dataView.count);
 
          if (outputAccessor.componentType == AccessorComponentType::Float) {
            for (uint32_t j = 0; j < dataView.count; j++) {
              const float time = getTime(j, dataView.data, dataView.stride);
              glm::vec4 rot = *reinterpret_cast<const glm::vec4*>(oDataView.data + oDataView.stride * j);
              track.rotations[j] = RotationKey{ time, glm::quat(rot.w, rot.x, rot.y, rot.z) };
            }
          }
        }
        else {
          LOG_ERROR(logger, "Unknown animation channel path: %s", channel.path.c_str());
        }
      }
    }
    if (model.animation) {
      model.animation->skeleton = model.skeleton;
    }
    return true;
  }
};
 
namespace Cogs::Core::GltfLoader {
  bool
    GltfLoader::canLoad(Context* context, const ModelLoadInfo& loadInfo)
  {
    // If loader is disabled, just return false.
    if (Variable* enable = context->variables->get(enableVariableName); !enable->isEmpty() && enable->getBool() == false) {
      return false;
    }
 
    // If 'resourcePath' is an URL then it might contain parameters which will mess
    // up the extension-test. Remove all parameters -- if found.
    std::string resourcePath = loadInfo.resourcePath;
    if (resourcePath.starts_with("http")) {
      size_t paramPos = resourcePath.find('?');
      if (paramPos != std::string::npos) {
        resourcePath = resourcePath.substr(0, paramPos);
      }
    }
 
    auto extension = Cogs::IO::extension(resourcePath);
    if (extension.starts_with(".gltf")) return true;
    if (extension.starts_with(".glb")) return true;
    if (extension.starts_with(".b3dm")) return true; // B3DM is just a wrapped glTF/glb file
    return false;
  }
 
  size_t GltfLoader::getPotentialB3DMOffset(uint8_t* content, size_t size)
  {
    struct B3DMHeader {
      uint32_t magic;
      uint32_t version;
      uint32_t length;
      uint32_t featureTableJSONLength;
      uint32_t featureTableBinaryLength;
      uint32_t batchTableJSONLength;
      uint32_t batchTableBinaryLength;
    };
 
    const uint32_t b3dmMagic = uint32_t('b') + uint32_t('3' << 8) + uint32_t('d' << 16) + uint32_t('m' << 24);
    B3DMHeader* header = reinterpret_cast<B3DMHeader*>(content);
 
    if (header->magic != b3dmMagic) {
      return 0; // This is not a B3DM file
    }
 
    assert(header->length <= size && "Invalid length value in header");
 
    if (header->version != 1) {
      LOG_ERROR(logger, "The B3DM file is not version 1.0");
      return 0;
    }
 
    uint32_t featureTableStart = sizeof(B3DMHeader);
    uint32_t batchTableStart = featureTableStart + header->featureTableJSONLength + header->featureTableBinaryLength;
    uint32_t glbStart = batchTableStart + header->batchTableJSONLength + header->batchTableBinaryLength;
 
    assert(glbStart < size && "Offset out of bounds");
    return glbStart;
  }
 
  bool GltfLoader::load(Context* context, const ModelLoadInfo& loadInfo, std::unique_ptr<Cogs::FileContents> contents)
  {
    LOG_TRACE(logger, "Loading model: '%s'", loadInfo.resourceName.c_str());
 
    Cogs::Memory::MemoryBuffer content = contents->take();
 
    if (!content.size()) {
      LOG_ERROR(logger, "Could not open file '%s'.", loadInfo.resourcePath.c_str());
      return false;
    }
 
    // If this file is actually a B3DM file, we'll calculate the amount of bytes to skip to
    // load the actual GLTF data.
    const size_t fileOffset = getPotentialB3DMOffset(static_cast<uint8_t*>(content.data()), content.size());
    const uint8_t* dataPtr = (uint8_t*)(content.data()) + fileOffset;
 
    struct GlbHeader
    {
      uint32_t magic;
      uint32_t version;
      uint32_t length;
    };
 
    struct GlbChunkHeader
    {
      uint32_t length;
      uint32_t type;
    };
 
    struct GlbChunk
    {
      GlbChunkHeader header;
      char data[1];
    };
 
    JsonParseFlags flags = JsonParseFlags::NoCachedContent;
    const Cogs::StringView path = loadInfo.resourcePath;
 
    Document document;
    const GlbHeader* header = (const GlbHeader*) dataPtr;
    GltfModelDefinition loadData(context, loadInfo.resourcePath);
    loadData.default_material = -1;
    if (auto var = context->variables->get(optimizeVariableName); !var->isEmpty()) {
      loadData.optimizationLevel = unsigned(std::max(0, var->getInt()));
    }
 
    std::span<const uint8_t> glb_data;
    if (sizeof(GlbHeader) <= content.size() && header->magic == 0x46546C67) {
      loadData.version = header->version * 100;
 
      if (header->version != 2) {
        LOG_ERROR(logger, "Unable to load glb format %d", loadData.version);
        return false;
      }
 
      size_t offset = sizeof(GlbHeader);
      uint32_t i = 0;
      while (offset < (content.size() - fileOffset)) {
        const GlbChunk* chunk = (GlbChunk*)(reinterpret_cast<const char*>(dataPtr) + offset);
        if (chunk->header.type == 0x4E4F534A)
          document = parseJson(Cogs::StringView(chunk->data, chunk->header.length), flags);
        else if (chunk->header.type == 0x004E4942)
          glb_data = std::span((const uint8_t*)chunk->data, (const uint8_t*)chunk->data + chunk->header.length);
        else {
          LOG_ERROR(logger, "Unknown glb chunk type 0x%x (index %d)", chunk->header.type, i);
        }
        offset += chunk->header.length + sizeof(GlbChunkHeader);
        i++;
      }
    }
    else {
      document = parseJson(Cogs::StringView(reinterpret_cast<const char*>(dataPtr), content.size() - fileOffset), flags);
    }
 
    if (!document.IsObject()) {
      LOG_ERROR(logger, "Could not load asset file %s: JSON root is not an object.", loadInfo.resourceName.c_str());
      return false;
    }
 
    auto& modelManager = *context->modelManager;
    auto model = modelManager.lock(loadInfo.handle);
 
    MeshoptDecompressor meshoptDecomp;
 
    auto root = document.GetObject();
 
    // Asset
    if (const auto& assetItem = root.FindMember("asset"); assetItem != root.MemberEnd()) {
      if (!parseAsset(loadData, path, assetItem->value)) return false;
    }
    else {
      LOG_ERROR(logger, "%.*s: No required JSON asset member", StringViewFormat(path));
      return false;
    }
 
    if (const auto& buffersItem = root.FindMember("buffers"); buffersItem != root.MemberEnd()) {
      if (!parseBuffers(context, loadData, path, buffersItem->value, glb_data)) {
        return false;
      }
    }
 
    if (const auto& bufferViewsItem = root.FindMember("bufferViews"); bufferViewsItem != root.MemberEnd()) {
      if (!parseBufferViews(loadData, path, bufferViewsItem->value, meshoptDecomp)) {
        return false;
      }
    }
 
    if (const auto& imagesItem = root.FindMember("images"); imagesItem != root.MemberEnd()) {
      if (!parseImages(context, loadData, imagesItem->value)) {
        return false;
      }
    }
 
    if (const auto& samplersItem = root.FindMember("samplers"); samplersItem != root.MemberEnd()) {
      if (!parseSamplers(loadData, path, samplersItem->value)) {
        return false;
      }
    }
 
    if (const auto& texturesItem = root.FindMember("textures"); texturesItem != root.MemberEnd()) {
      if (!parseTextures(loadData, path, texturesItem->value)) {
        return false;
      }
    }
 
    if (auto materialsItem = root.FindMember("materials"); materialsItem != root.MemberEnd()) {
      if (!checkIsArray(loadData, *materialsItem)) return false;
      for (const Value& materialsElement : materialsItem->value.GetArray()) {
        if (!checkIsObject(loadData, "materials element", materialsElement)) {
          return false;
        }
        loadData.materialsArray.emplace_back(materialsElement.GetObject());
      }
    }
 
    if (auto meshesItem = root.FindMember("meshes"); meshesItem != root.MemberEnd()) {
      if (!checkIsArray(loadData, *meshesItem)) return false;
      for (const Value& meshesElement : meshesItem->value.GetArray()) {
        if (!checkIsObject(loadData, "meshes element", meshesElement)) {
          return false;
        }
        loadData.meshesArray.emplace_back(meshesElement.GetObject());
      }
    }
 
    for (const auto& section : root) {
      switch (toView(section.name).hash()) {
      case Cogs::hash("asset"):
      case Cogs::hash("buffers"):
      case Cogs::hash("bufferViews"):
      case Cogs::hash("images"):
      case Cogs::hash("samplers"):
      case Cogs::hash("textures"):
      case Cogs::hash("materials"):
      case Cogs::hash("meshes"):
      case Cogs::hash("cameras"):     // ignored for now
        break;
 
      case Cogs::hash("nodes"):
        if (!parseNodes(loadData, path, section.value)) return false;
        break;
 
      case Cogs::hash("scenes"):
        if (!parseScenes(loadData, path, section.value)) return false;
        break;
 
      case Cogs::hash("scene"):
        loadData.load_scene = section.value.GetUint();
        break;
 
      case Cogs::hash("accessors"):
        if (!checkIsArray(loadData, section)) return false;
        if (!parseAccessors(loadData, path, section.value)) return false;
        break;
 
      case Cogs::hash("skins"):
        if (!parseSkins(loadData, path, section.value)) return false;
        break;
 
      case Cogs::hash("animations"):
        if (!parseAnimations(loadData, path, section.value)) return false;
        break;
 
      case Cogs::hash("extensionsRequired"):
        for (auto& extension : section.value.GetArray()) {
          if (extension.GetString() == Cogs::StringView("KHR_materials_pbrSpecularGlossiness") ||
              extension.GetString() == Cogs::StringView("KHR_draco_mesh_compression") ||
              extension.GetString() == Cogs::StringView("KHR_mesh_quantization") ||
              extension.GetString() == Cogs::StringView("KHR_materials_unlit") ||
              extension.GetString() == Cogs::StringView("KHR_texture_transform") ||
              extension.GetString() == Cogs::StringView("KHR_texture_basisu") || // NOTE: The KTX v2 image format is not supported yet.
              extension.GetString() == Cogs::StringView("EXT_meshopt_compression")) {
            // https://github.com/KhronosGroup/glTF/tree/main/extensions/2.0/Khronos/KHR_draco_mesh_compression
            // https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Vendor/EXT_meshopt_compression
            // https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_materials_unlit
            // https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_mesh_quantization
            // https://github.com/KhronosGroup/glTF/blob/main/extensions/2.0/Khronos/KHR_texture_transform
            // LOG_DEBUG(logger, "Required extension used: %s", extension.GetString());
          }
          else {
            LOG_ERROR(logger, "Unknown required extension: %s", extension.GetString());
            return false;
          }
        }
        break;
 
      case Cogs::hash("extensions"):
      case Cogs::hash("extensionsUsed"):
        if (section.value.IsArray()) {
          for (auto& extension : section.value.GetArray()) {
            if (extension.GetString() == Cogs::StringView("KHR_materials_pbrSpecularGlossiness") ||
                extension.GetString() == Cogs::StringView("KHR_materials_specular") ||
                extension.GetString() == Cogs::StringView("KHR_materials_ior") ||
                extension.GetString() == Cogs::StringView("KHR_draco_mesh_compression") ||
                extension.GetString() == Cogs::StringView("KHR_mesh_quantization") ||
                extension.GetString() == Cogs::StringView("KHR_texture_transform") ||
                extension.GetString() == Cogs::StringView("KHR_texture_basisu") || // NOTE: The KTX v2 image format is not supported yet.
                extension.GetString() == Cogs::StringView("EXT_meshopt_compression") ||
                extension.GetString() == Cogs::StringView("KHR_materials_unlit")) {
              // LOG_DEBUG(logger, "Extension used: %s", extension.GetString());
            }
            else {
              LOG_WARNING(logger, "Unknown extension: %s", extension.GetString());
            }
          }
        }
        else if (section.value.IsObject()) {
          for (const auto& extension : section.value.GetObject()) {
            LOG_WARNING(logger, "Unknown extension: %s", extension.name.GetString());
          }
        }
        else {
          LOG_WARNING(logger, "Unknown extension: %s", section.value.GetString());
        }
        break;
 
      default:
        LOG_WARNING(logger, "%.*s: Unrecognized root key %s", StringViewFormat(path), section.name.GetString());
        break;
      }
    }
 
    uint32_t sceneIndex = 0;
    for (auto& scene : loadData.scenes) {
      if (sceneIndex > 1) {
        LOG_ERROR(logger, "Loader unable to handle more than one scene.");
        break;
      }
 
      model->setName(scene.name);
 
      //NOTE: We insert a virtual root node rotating the models from the Y-up system used by glTF to our
      // Z-up convention. If other usage is desired we could replace this with a more configurable approach.
      auto& root_ = model->parts.emplace_back();
      model->setPartTransform(root_, glm::rotate(glm::mat4(1.0f), glm::half_pi<float>(), glm::vec3(1, 0, 0)));
      model->setPartName(root_, "CogsRoot");
 
      // Leave the model root transform alone, used to calculate internal model transforms.
      glm::mat4 rootTransform(1.0f);
 
      for (uint32_t nodeIndex : scene.nodes) {
        assert(nodeIndex < loadData.nodes.size());
 
        if (!loadBone(loadData, loadData.nodes[nodeIndex], model->skeleton, (size_t)-1, rootTransform)) {
          return false;
        }
 
        if (!loadJoints(loadData, loadData.nodes[nodeIndex], model->skeleton, meshoptDecomp)) {
            return false;
        }
 
        // Load root nodes from glTF using our virtual root node with index==0 as parent.
        if (!loadNode(context, loadData, loadData.nodes[nodeIndex], *model, 0, rootTransform, meshoptDecomp)) {
          return false;
        }
      }
 
      if (!loadAnimation(context, loadData, *model, meshoptDecomp)) {
        return false;
      }
    }
 
    for (auto const & it : loadData.debugMessages) {
      LOG_TRACE(logger, "%s (x %u)", it.first.c_str(), it.second);
    }
    return true;
  }
 
  bool GltfLoader::load(Context* context, const ModelLoadInfo& loadInfo)
  {
    JsonParseFlags flags = JsonParseFlags::NoCachedContent;
#ifdef EMSCRIPTEN
    const auto resourceFlags = ResourceStoreFlags::None;
#else
    const auto resourceFlags = (flags & JsonParseFlags::NoCachedContent) == JsonParseFlags::NoCachedContent
      ? ResourceStoreFlags::NoCachedContent
      : ResourceStoreFlags::None;
#endif
 
    std::unique_ptr<Cogs::FileContents> contents;
#ifdef COGS_USE_MMAP
    if (loadInfo.protocol == ResourceProtocol::Archive) {
#endif
      ResourceBuffer buffer = context->resourceStore->getResourceContents(loadInfo.resourcePath);
      if (!buffer.buffer->data()) {
        LOG_ERROR(logger, "Could not load resource data for model %s.", loadInfo.resourcePath.c_str());
        return false;
      }
      contents = std::make_unique<Cogs::Platform::ResourceBufferBackedFileContents>(buffer, loadInfo.resourcePath, Cogs::FileContentsHints::None);
#ifdef COGS_USE_MMAP
    }
    else {
      Cogs::FileHandle::Ptr file = Cogs::IO::openFile(loadInfo.resourcePath, Cogs::FileHandle::OpenMode::OpenAlways, Cogs::FileHandle::AccessMode::Read);
      if (!file) {
        LOG_ERROR(logger, "Could not open file %s for mapping.", loadInfo.resourcePath.c_str());
        return false;
      }
 
      size_t size = Cogs::IO::fileSize(file);
      if (!size) {
        LOG_ERROR(logger, "File size invalid: %zd.", size);
        return false;
      }
 
      const uint8_t* ptr = static_cast<const uint8_t*>(Cogs::IO::mapFile(file, Cogs::FileHandle::ProtectionMode::ReadOnly, 0, size));
      if (!ptr) {
        LOG_ERROR(logger, "Could not map file %s for reading model data.", loadInfo.resourcePath.c_str());
        return false;
      }
 
      contents = std::make_unique<Cogs::MMapBackedFileContents>(ptr, size, file, loadInfo.resourcePath, Cogs::FileContentsHints::None);
    }
#endif
 
    const Cogs::StringView path = loadInfo.resourcePath;
    const ResourceBuffer content = context->resourceStore->getResourceContents(path, resourceFlags);
 
    return load(context, loadInfo, std::move(contents));
  }
 
  inline GltfModelDefinition::GltfModelDefinition(Context* context, Cogs::StringView path) :
    context(context),
    path(path)
  {
    timer = Cogs::Timer::startNew();
    rootTask = context->taskManager->createGroup(context->taskManager->ResourceQueue);
  }
 
  inline GltfModelDefinition::~GltfModelDefinition()
  {
    context->taskManager->wait(rootTask);
    for (auto& image : images) {
      if (image.decoded.data) {
        stbi_image_free(image.decoded.data);
        image.decoded.data = nullptr;
      }
    }
    LOG_TRACE(logger, "Gltf elapsed: %f.", timer.elapsedSeconds());
  }
}