CogsBin3Loader.cpp

#include "Context.h"
#include "ModelLoader.h"
#include "CogsBin3.h"
 
#include "Resources/Buffer.h"
#include "Resources/ResourceStore.h"
#include "Resources/ModelManager.h"
#include "Resources/MeshManager.h"
#include "Resources/MaterialManager.h"
#include "Resources/TextureManager.h"
#include "Resources/AnimationManager.h"
#include "Resources/BufferManager.h"
 
#include "Platform/ResourceBufferBackedFileContents.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/Geometry/BoundingBox.hpp"
#include "Foundation/Platform/FileHandle.h"
#include "Foundation/Platform/IO.h"
#include "Foundation/Platform/MMapBackedFileContents.h"
#include "Foundation/Platform/Threads.h"
#include "Foundation/Platform/Timer.h"
 
#include "zstd.h"
#include <span>
#include <type_traits>
 
// Use of sub-tasks for loading will be disabled when more than the
// following number of models are currently in flight...
// Increasing this number could lead to a stack overflow if many
// models are being loaded concurrently.
#define COGS_MODELLOADER_MAX_TASKS  20
 
//#pragma optimize( "", off )
 
#ifndef EMSCRIPTEN
// Toggle using memory mapped IO when reading file.
#define COGS_USE_MMAP
#endif
 
// NOTE (chrisdy): I've tried to use asserts on errors resulting from bugs/illegal usage from cogs code,
//                 But illegal data in file should only produce errors and bail out.
 
namespace
{
  using namespace Cogs::Core;
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("CogsBin3Loader");
  std::atomic<uint32_t> loadCount(0);
 
  template<typename T>
  struct TypedView
  {
    const T* base = nullptr;
    size_t count = 0;
 
    const T& operator[](size_t i) const { assert(i < count); return base[i]; }
  };
 
  template<typename T>
  constexpr bool isValidIndex(T v)
  {
    static_assert(std::is_integral_v<T>);
    return v != T(-1);
  }
 
  struct ReadContext
  {
    Context* context = nullptr;
    std::unique_ptr<Cogs::FileContents> contents;
    Cogs::Core::TaskId group = NoTask;
    std::string path;
    bool success = false;
 
    CogsBin3::Header* header = nullptr;
    std::span<CogsBin3::SectionInfo> sectionInfo;
    std::vector<const uint8_t*> sectionPtr;
    std::unique_ptr<Cogs::Mutex[]> sectionLocks;
    Cogs::Mutex buffersMutex;
 
    TypedView<CogsBin3::Buffer>             buffers;
    TypedView<CogsBin3::Texture>            textures;
    TypedView<CogsBin3::String>             strings;
    TypedView<char>                         stringData;
    TypedView<CogsBin3::Node>               nodes;
    TypedView<CogsBin3::Transform>          transforms;
    TypedView<Cogs::Geometry::BoundingBox>  boundingBoxes;
    TypedView<CogsBin3::MaterialInstance>   materialInstances;
    TypedView<CogsBin3::Property>           props;
    TypedView<uint8_t>                      propData;
    TypedView<CogsBin3::Mesh>               meshes;
    TypedView<CogsBin3::VertexStream>       vertexStreams;
    TypedView<CogsBin3::VertexAttribute>    vertexAttributes;
    TypedView<CogsBin3::Bone>               bones;
    TypedView<CogsBin3::Skeleton>           skeletons;
    TypedView<CogsBin3::AnimTrack>          animTracks;
    TypedView<CogsBin3::AnimClip>           animClips;
    TypedView<CogsBin3::Model>              models;
 
    std::vector<ResourceBufferHandle>       bufferCache;
    std::vector<TextureHandle>              textureCache;
 
    std::list<std::unique_ptr<uint8_t[]>> allocations; // we should have an arena here.
  };
 
  Cogs::PrimitiveType::EPrimitiveType translatePrimitiveType(ReadContext& rctx, CogsBin3::PrimitiveType primitiveType)
  {
    switch (primitiveType) {
    case CogsBin3::PrimitiveType::TriangleList:           return Cogs::PrimitiveType::TriangleList; break;
    case CogsBin3::PrimitiveType::TriangleStrip:          return Cogs::PrimitiveType::TriangleStrip; break;
    case CogsBin3::PrimitiveType::LineList:               return Cogs::PrimitiveType::LineList; break;
    case CogsBin3::PrimitiveType::LineStrip:              return Cogs::PrimitiveType::LineStrip; break;
    case CogsBin3::PrimitiveType::PointList:              return Cogs::PrimitiveType::PointList; break;
    case CogsBin3::PrimitiveType::TriangleListAdjacency:  return Cogs::PrimitiveType::TriangleListAdjacency; break;
    case CogsBin3::PrimitiveType::TriangleStripAdjacency: return Cogs::PrimitiveType::TriangleStripAdjacency; break;
    case CogsBin3::PrimitiveType::LineListAdjacency:      return Cogs::PrimitiveType::LineListAdjacency; break;
    case CogsBin3::PrimitiveType::LineStripAdjacency:     return Cogs::PrimitiveType::LineStripAdjacency; break;
    case CogsBin3::PrimitiveType::ControlPoint1PatchList: return Cogs::PrimitiveType::ControlPoint1PatchList; break;
    case CogsBin3::PrimitiveType::ControlPoint2PatchList: return Cogs::PrimitiveType::ControlPoint2PatchList; break;
    case CogsBin3::PrimitiveType::ControlPoint3PatchList: return Cogs::PrimitiveType::ControlPoint3PatchList; break;
    case CogsBin3::PrimitiveType::ControlPoint4PatchList: return Cogs::PrimitiveType::ControlPoint4PatchList; break;
    default:
      break;
    }
    rctx.success = false;
    LOG_ERROR(logger, "Illegal primitive type: %u", unsigned(primitiveType));
    return Cogs::PrimitiveType::TriangleList;
  }
 
  const uint8_t* sectionPointer(ReadContext& rctx, uint32_t index)
  {
    // FIXME (chrisdy): Should we leave this one around indefinitely?
    thread_local ZSTD_DCtx* zstd_dctx = nullptr;
 
    assert(index < rctx.header->sectionCount);
 
    Cogs::LockGuard lock(rctx.sectionLocks[index]);
    const auto & sectionInfo = rctx.sectionInfo[index];
    if (rctx.sectionPtr[index] == nullptr) {
      //LOG_DEBUG(logger, "%zx Resolving section %u (compr=%d, size=%zd, fileOffset=%zu, fileSize=%zu)",
      //          std::hash<std::thread::id>{}(std::this_thread::get_id()),
      //          index,
      //          sectionInfo.compression,
      //          size_t(sectionInfo.uncompressedSize),
      //          size_t(sectionInfo.fileOffset),
      //          size_t(sectionInfo.fileSize));
      switch (rctx.sectionInfo[index].compression)
      {
      case CogsBin3::Compression::None:
        rctx.sectionPtr[index] = rctx.contents->ptr + rctx.sectionInfo[index].fileOffset;
        break;
      case CogsBin3::Compression::ZSTD: {
        if (zstd_dctx == nullptr) {
          zstd_dctx = ZSTD_createDCtx();
        }
 
        // Allocate mem for uncompressed data. Clamp it to minimum 1 bytes so we don't get a nullptr
        // for empty sections, as we use a null pointer to flag that something has gone horribly
        // wrong and we give up.
        rctx.allocations.emplace_back(new uint8_t[sectionInfo.uncompressedSize ? sectionInfo.uncompressedSize : 1]);
        rctx.sectionPtr[index] = rctx.allocations.back().get();
 
        auto result = ZSTD_decompressDCtx(zstd_dctx,
                                          rctx.allocations.back().get(), sectionInfo.uncompressedSize,
                                          rctx.contents->ptr + sectionInfo.fileOffset, sectionInfo.fileSize);
        if (ZSTD_isError(result)) {
          LOG_ERROR(logger, "zstd decompression failed: %s", ZSTD_getErrorName(result));
          return nullptr;
        }
        else if (result != sectionInfo.uncompressedSize) {
          LOG_ERROR(logger, "Uncompressed data size didn't match size recorded in file.");
          return nullptr;
        }
        break;
      }
      default:
        LOG_ERROR(logger, "Illegal compression flag on section.");
        return nullptr;
      }
    }
    return rctx.sectionPtr[index];
  }
 
  Cogs::StringView getString(ReadContext& rctx, uint32_t ix)
  {
    if (ix < rctx.strings.count) {
      auto &           str = rctx.strings[ix];
      Cogs::StringView rv(rctx.stringData.base + str.offset, str.length);
      //LOG_DEBUG(logger, "Retrieved string %.*s", StringViewFormat(rv));
      return rv;
    }
    else if (!isValidIndex(ix)) {
      return Cogs::StringView();
    }
    else {
      LOG_ERROR(logger, "Invalid string index %u", ix);
      rctx.success = false;
      return Cogs::StringView();
    }
  }
 
  const Cogs::Geometry::BoundingBox& getBoundingBox(ReadContext& rctx, uint32_t ix)
  {
    if (ix < rctx.boundingBoxes.count) {
      return rctx.boundingBoxes[ix];
    }
    else {
      rctx.success = false;
      LOG_ERROR(logger, "Invalid bounding box index %u", ix);
      static const Cogs::Geometry::BoundingBox empty = Cogs::Geometry::makeEmptyBoundingBox<Cogs::Geometry::BoundingBox>();
      return empty;
    }
  }
 
  Cogs::TextureFormat getTextureFormat(ReadContext& /*rctx*/, CogsBin3::Format format)
  {
    switch (format) {
    case CogsBin3::Format::Unknown:             return Cogs::TextureFormat::Unknown; break;
    case CogsBin3::Format::R8_UINT:             return Cogs::TextureFormat::R8_UINT; break;
    case CogsBin3::Format::R8G8_UINT:           return Cogs::TextureFormat::R8G8_UINT; break;
    case CogsBin3::Format::R8G8B8_UINT:         return Cogs::TextureFormat::R8G8B8_UINT; break;
    case CogsBin3::Format::R8G8B8A8_UINT:       return Cogs::TextureFormat::R8G8B8A8_UINT; break;
    case CogsBin3::Format::R16_UINT:            return Cogs::TextureFormat::R16_UINT; break;
    case CogsBin3::Format::R16G16_UINT:         return Cogs::TextureFormat::R16G16_UINT; break;
    case CogsBin3::Format::R16G16B16_UINT:      return Cogs::TextureFormat::R16G16B16_UINT; break;
    case CogsBin3::Format::R16G16B16A16_UINT:   return Cogs::TextureFormat::R16G16B16A16_UINT; break;
    case CogsBin3::Format::R32_UINT:            return Cogs::TextureFormat::R32_UINT; break;
    case CogsBin3::Format::R32G32_UINT:         return Cogs::TextureFormat::R32G32_UINT; break;
    case CogsBin3::Format::R32G32B32_UINT:      return Cogs::TextureFormat::R32G32B32_UINT; break;
    case CogsBin3::Format::R32G32B32A32_UINT:   return Cogs::TextureFormat::R32G32B32A32_UINT; break;
    case CogsBin3::Format::R8_SINT:             return Cogs::TextureFormat::R8_SINT; break;
    case CogsBin3::Format::R8G8_SINT:           return Cogs::TextureFormat::R8G8_SINT; break;
    case CogsBin3::Format::R8G8B8_SINT:         return Cogs::TextureFormat::R8G8B8_SINT; break;
    case CogsBin3::Format::R8G8B8A8_SINT:       return Cogs::TextureFormat::R8G8B8A8_SINT; break;
    case CogsBin3::Format::R16_SINT:            return Cogs::TextureFormat::R16_SINT; break;
    case CogsBin3::Format::R16G16_SINT:         return Cogs::TextureFormat::R16G16_SINT; break;
    case CogsBin3::Format::R16G16B16_SINT:      return Cogs::TextureFormat::R16G16B16_SINT; break;
    case CogsBin3::Format::R16G16B16A16_SINT:   return Cogs::TextureFormat::R16G16B16A16_SINT; break;
    case CogsBin3::Format::R32_SINT:            return Cogs::TextureFormat::R32_SINT; break;
    case CogsBin3::Format::R32G32_SINT:         return Cogs::TextureFormat::R32G32_SINT; break;
    case CogsBin3::Format::R32G32B32_SINT:      return Cogs::TextureFormat::R32G32B32_SINT; break;
    case CogsBin3::Format::R32G32B32A32_SINT:   return Cogs::TextureFormat::R32G32B32A32_SINT; break;
    case CogsBin3::Format::R16_FLOAT:           return Cogs::TextureFormat::R16_FLOAT; break;
    case CogsBin3::Format::R16G16_FLOAT:        return Cogs::TextureFormat::R16G16_FLOAT; break;
    case CogsBin3::Format::R16G16B16_FLOAT:     return Cogs::TextureFormat::R16G16B16_FLOAT; break;
    case CogsBin3::Format::R16G16B16A16_FLOAT:  return Cogs::TextureFormat::R16G16B16A16_FLOAT; break;
    case CogsBin3::Format::R32_FLOAT:           return Cogs::TextureFormat::R32_FLOAT; break;
    case CogsBin3::Format::R32G32_FLOAT:        return Cogs::TextureFormat::R32G32_FLOAT; break;
    case CogsBin3::Format::R32G32B32_FLOAT:     return Cogs::TextureFormat::R32G32B32_FLOAT; break;
    case CogsBin3::Format::R32G32B32A32_FLOAT:  return Cogs::TextureFormat::R32G32B32A32_FLOAT; break;
    case CogsBin3::Format::R64_FLOAT:           assert(false && "Illegal texture format");  break;
    case CogsBin3::Format::R64G64_FLOAT:        assert(false && "Illegal texture format"); break;
    case CogsBin3::Format::R64G64B64_FLOAT:     assert(false && "Illegal texture format"); break;
    case CogsBin3::Format::R64G65B64A64_FLOAT:  assert(false && "Illegal texture format"); break;
    case CogsBin3::Format::R8_UNORM:            return Cogs::TextureFormat::R8_UNORM; break;
    case CogsBin3::Format::R8G8_UNORM:          return Cogs::TextureFormat::R8G8_UNORM; break;
    case CogsBin3::Format::R8G8B8_UNORM:        return Cogs::TextureFormat::R8G8B8_UNORM; break;
    case CogsBin3::Format::R8G8B8A8_UNORM:      return Cogs::TextureFormat::R8G8B8A8_UNORM; break;
    case CogsBin3::Format::R16_UNORM:           return Cogs::TextureFormat::R16_UNORM; break;
    case CogsBin3::Format::R16G16_UNORM:        return Cogs::TextureFormat::R16G16_UNORM; break;
    case CogsBin3::Format::R16G16B16_UNORM:     return Cogs::TextureFormat::R16G16B16_UNORM; break;
    case CogsBin3::Format::R16G16B16A16_UNORM:  return Cogs::TextureFormat::R16G16B16A16_UNORM; break;
    case CogsBin3::Format::R8_SNORM:            return Cogs::TextureFormat::R8_SNORM; break;
    case CogsBin3::Format::R8G8_SNORM:          return Cogs::TextureFormat::R8G8_SNORM; break;
    case CogsBin3::Format::R8G8B8_SNORM:        return Cogs::TextureFormat::R8G8B8_SNORM; break;
    case CogsBin3::Format::R8G8B8A8_SNORM:      return Cogs::TextureFormat::R8G8B8A8_SNORM; break;
    case CogsBin3::Format::R16_SNORM:           return Cogs::TextureFormat::R16_SNORM; break;
    case CogsBin3::Format::R16G16_SNORM:        return Cogs::TextureFormat::R16G16_SNORM; break;
    case CogsBin3::Format::R16G16B16_SNORM:     return Cogs::TextureFormat::R16G16B16_SNORM; break;
    case CogsBin3::Format::R16G16B16A16_SNORM:  return Cogs::TextureFormat::R16G16B16A16_SNORM; break;
    case CogsBin3::Format::D16_UNORM:           return Cogs::TextureFormat::D16_UNORM; break;
    case CogsBin3::Format::D24_UNORM:           return Cogs::TextureFormat::D24_UNORM; break;
    case CogsBin3::Format::D24S8_UNORM:         return Cogs::TextureFormat::D24S8_UNORM; break;
    case CogsBin3::Format::D32_FLOAT:           return Cogs::TextureFormat::D32_FLOAT; break;
    case CogsBin3::Format::R32_TYPELESS:        return Cogs::TextureFormat::R32_TYPELESS; break;
    case CogsBin3::Format::R16_TYPELESS:        return Cogs::TextureFormat::R16_TYPELESS; break;
    case CogsBin3::Format::R8T:                 return Cogs::TextureFormat::R8T; break;
    case CogsBin3::Format::R8G8T:               return Cogs::TextureFormat::R8G8T; break;
    case CogsBin3::Format::R8G8B8T:             return Cogs::TextureFormat::R8G8B8T; break;
    case CogsBin3::Format::R8G8B8A8T:           return Cogs::TextureFormat::R8G8B8A8T; break;
    case CogsBin3::Format::B8G8R8:              return Cogs::TextureFormat::B8G8R8; break;
    case CogsBin3::Format::B8G8R8A8:            return Cogs::TextureFormat::B8G8R8A8; break;
    case CogsBin3::Format::A8_UNORM:            return Cogs::TextureFormat::A8_UNORM; break;
    case CogsBin3::Format::BC1_TYPELESS:        return Cogs::TextureFormat::BC1_TYPELESS; break;
    case CogsBin3::Format::BC1_UNORM:           return Cogs::TextureFormat::BC1_UNORM; break;
    case CogsBin3::Format::BC1_UNORM_SRGB:      return Cogs::TextureFormat::BC1_UNORM_SRGB; break;
    case CogsBin3::Format::BC2_TYPELESS:        return Cogs::TextureFormat::BC2_TYPELESS; break;
    case CogsBin3::Format::BC2_UNORM:           return Cogs::TextureFormat::BC2_UNORM; break;
    case CogsBin3::Format::BC2_UNORM_SRGB:      return Cogs::TextureFormat::BC2_UNORM_SRGB; break;
    case CogsBin3::Format::BC3_TYPELESS:        return Cogs::TextureFormat::BC3_TYPELESS; break;
    case CogsBin3::Format::BC3_UNORM:           return Cogs::TextureFormat::BC3_UNORM; break;
    case CogsBin3::Format::BC3_UNORM_SRGB:      return Cogs::TextureFormat::BC3_UNORM_SRGB; break;
    case CogsBin3::Format::BC4_TYPELESS:        return Cogs::TextureFormat::BC4_TYPELESS; break;
    case CogsBin3::Format::BC4_UNORM:           return Cogs::TextureFormat::BC4_UNORM; break;
    case CogsBin3::Format::BC4_SNORM:           return Cogs::TextureFormat::BC4_SNORM; break;
    case CogsBin3::Format::BC5_TYPELESS:        return Cogs::TextureFormat::BC5_TYPELESS; break;
    case CogsBin3::Format::BC5_UNORM:           return Cogs::TextureFormat::BC5_UNORM; break;
    case CogsBin3::Format::BC5_SNORM:           return Cogs::TextureFormat::BC5_SNORM; break;
    case CogsBin3::Format::R8G8B8A8_UNORM_SRGB: return Cogs::TextureFormat::R8G8B8A8_UNORM_SRGB; break;
    default:
      assert(false && "Illegal format");
      break;
    }
    return Cogs::TextureFormat::Unknown;
  }
 
  Cogs::VertexFormatHandle getVertexFormat(ReadContext& rctx, uint32_t firstAttribute, uint32_t attributeCount)
  {
    const auto * attributes = rctx.vertexAttributes.base + firstAttribute;
 
    std::vector<Cogs::VertexElement> elements;
    elements.resize(attributeCount);
    for (unsigned i = 0; i < attributeCount; i++) {
      const auto & attribute = attributes[i];
 
      auto & element = elements[i];
      element.offset = attribute.offset;
      element.format = (Cogs::DataFormat)attribute.format;
 
      switch (attribute.semantic) {
      case CogsBin3::Semantic::Position:        element.semantic = Cogs::ElementSemantic::Position; break;
      case CogsBin3::Semantic::Normal:          element.semantic = Cogs::ElementSemantic::Normal; break;
      case CogsBin3::Semantic::Color:           element.semantic = Cogs::ElementSemantic::Color; break;
      case CogsBin3::Semantic::TexCoord:        element.semantic = Cogs::ElementSemantic::TextureCoordinate; break;
      case CogsBin3::Semantic::Tangent:         element.semantic = Cogs::ElementSemantic::Tangent; break;
      case CogsBin3::Semantic::InstanceVector:  element.semantic = Cogs::ElementSemantic::InstanceVector; break;
      case CogsBin3::Semantic::InstanceMatrix:  element.semantic = Cogs::ElementSemantic::InstanceMatrix; break;
      default:
        LOG_ERROR(logger, "Illegal vertex element semantic %u", unsigned(attribute.semantic));
        return {};
      }
      element.semanticIndex = attribute.semanticIndex;
      if (attribute.instanceStepRate == 0) {
        element.inputType = Cogs::InputType::VertexData;
        element.instanceStep = 0;
      }
      else {
        element.inputType = Cogs::InputType::InstanceData;
        element.instanceStep = attribute.instanceStepRate - 1;
      }
      element.inputType = attribute.instanceStepRate == 0 ? Cogs::InputType::VertexData : Cogs::InputType::InstanceData;
      element.instanceStep = attribute.instanceStepRate;
    }
 
    return Cogs::VertexFormats::createVertexFormat(elements.data(), elements.size());
  }
 
  const uint8_t* resolveDataOffset(ReadContext& rctx, uint64_t offset, uint32_t size)
  {
    const auto sectionIx = uint16_t(offset >> 48);
    const auto * section = sectionPointer(rctx, sectionIx);
    if (section == nullptr) {
      LOG_ERROR(logger, "Failed to retrieve data section %u", unsigned(sectionIx));
      rctx.success = false;
      return nullptr;
    }
    const auto sectionOffset = size_t(offset & 0xFFFFFFFFFFFFull);
    if (rctx.sectionInfo[sectionIx].uncompressedSize < sectionOffset + size) {
      LOG_ERROR(logger, "Stream source offset %zX size %u is outside section memory range.", sectionOffset, size);
      rctx.success = false;
      return nullptr;
    }
    return section + sectionOffset;
  }
 
  template<typename D, typename S>
  void widenAndCopy(std::span<D>& dstSpan, const S* src, uint32_t count)
  {
    auto * dst = dstSpan.data();
    // preserve notzeros. When narrowing in the writer, we check for
    // *less than*, so an actual value of 256 should trigger uint16_t storage.
    constexpr auto notzero = std::numeric_limits<S>::max();
    for (uint32_t i = 0; i < count; i++) {
      const auto v = *src++;
      if (v == notzero) *dst++ = ~D(0);
      else *dst++ = D(v);
    }
  }
 
  void populateMesh(ReadContext& rctx, MeshHandle handle, uint32_t index)
  {
    const auto & srcMesh = rctx.meshes[index];
    auto dstMesh = rctx.context->meshManager->lock(handle);
 
    if (isValidIndex(srcMesh.name)) {
      dstMesh->setName(getString(rctx, srcMesh.name));
    }
    if (isValidIndex(srcMesh.boundingBox)) {
      dstMesh->setBounds(getBoundingBox(rctx, srcMesh.boundingBox));
    }
    if ((srcMesh.flags & CogsBin3::MeshFlags::Clockwise) != 0) {
      dstMesh->setMeshFlag(MeshFlags::ClockwiseWinding);
    }
    if ((srcMesh.flags & CogsBin3::MeshFlags::Skinned) != 0) {
      dstMesh->setMeshFlag(MeshFlags::Skinned);
    }
 
    dstMesh->primitiveType = translatePrimitiveType(rctx, srcMesh.primitiveType);
 
    dstMesh->streams.resize(srcMesh.streamCount);
    for (size_t i = 0; i < srcMesh.streamCount; i++) {
      assert(srcMesh.firstStream + i < rctx.vertexStreams.count);
      const auto & srcStream = rctx.vertexStreams[srcMesh.firstStream + i];
 
      auto & dstStream = dstMesh->streams[i];
 
      {
        Cogs::LockGuard lock(rctx.buffersMutex);
        assert(srcStream.buffer < rctx.buffers.count);
 
        if (rctx.bufferCache[srcStream.buffer]) {
          dstStream.buffer = rctx.bufferCache[srcStream.buffer];
        } else {
          auto & dstBuffer = rctx.bufferCache[srcStream.buffer] = rctx.context->bufferManager->create();
          dstStream.buffer = dstBuffer;
 
          const auto & srcBuffer = rctx.buffers[srcStream.buffer];
          const auto * srcData = resolveDataOffset(rctx, srcBuffer.sectionOffset, srcBuffer.size);
 
          dstBuffer->reset(srcBuffer.size, rctx.context->memory->resourceAllocator);
          std::memcpy(dstBuffer->data(), srcData, srcBuffer.size);
 
          if ((srcBuffer.flags & CogsBin3::BufferContentFlags::VertexData) != 0) {
            dstBuffer->setBindFlags(BufferBindFlags::VertexBuffer);
          }
 
          if ((srcBuffer.flags & CogsBin3::BufferContentFlags::IndexData) != 0) {
            dstBuffer->setBindFlags(BufferBindFlags::IndexBuffer);
          }
        }
      }
 
      dstStream.numElements = srcStream.count;
      dstStream.type = VertexDataType::EVertexDataType(srcStream.vertexDataType);
      dstStream.stride = srcStream.stride;
      dstStream.offset = srcStream.offset;
 
      dstMesh->streamIndexes[dstStream.type] = uint8_t(i);
      dstMesh->streamsUpdated |= Mesh::toFlag(dstStream.type);
      dstMesh->setMeshFlag(MeshFlags::StreamsChanged);
 
      if (srcStream.vertexDataType < VertexDataType::LastVertexType) {
        dstStream.format = isValidIndex(srcStream.firstAttribute)
          ? getVertexFormat(rctx, srcStream.firstAttribute, srcStream.attributeCount)
          : Cogs::VertexFormatHandle{};
 
        if (!dstStream.format) {
          LOG_ERROR(logger, "Stream %zu has illegal format", i);
          return;
        }
 
        if (!dstMesh->isIndexed()) {
          switch (dstStream.type) {
          case VertexDataType::Positions:
          case VertexDataType::Interleaved0:
          case VertexDataType::Interleaved1:
            dstMesh->setCount(srcStream.count);
            break;
          default:
            break;
          }
        }
      } else if (srcStream.vertexDataType == VertexDataType::Indexes) {
        dstMesh->setCount(srcStream.count);
        dstMesh->setMeshFlag(MeshFlags::Indexed);
        dstMesh->setMeshFlag(MeshFlags::IndexesChanged);
      } else if (srcStream.vertexDataType == VertexDataType::SubMeshes) {
        dstMesh->submeshCount = (uint16_t)srcStream.count;
      }
    }
  }
 
 
  template<typename T>
  const T& getPropertyValue(ReadContext& rctx, const CogsBin3::Property& prop)
  {
    if constexpr (sizeof(T) <= sizeof(uint32_t)) {
      return *(const T*)(&prop.value);
    }
    else {
      if (prop.value < rctx.propData.count) {
        return *(const T*)(rctx.propData.base + prop.value);
      }
      else {
        LOG_ERROR(logger, "Illegal property data offset %u", prop.value);
        static T t = {};
        return t;
      }
    }
  }
 
  TextureHandle populateEmbeddedTexture(ReadContext& rctx, uint32_t textureIx)
  {
    assert(textureIx < rctx.textures.count);
    if (auto handle = rctx.textureCache[textureIx]; HandleIsValid(handle)) {
      return handle;
    }
    auto & tex = rctx.textures[textureIx];
 
 
    assert(tex.buffer < rctx.buffers.count);
    const auto & srcBuffer = rctx.buffers[tex.buffer];
    const auto * bufferData = resolveDataOffset(rctx, srcBuffer.sectionOffset, srcBuffer.size) + tex.offset;
 
    TextureLoadInfo * loadInfo = rctx.context->textureManager->createLoadInfo();
 
    loadInfo->resourceId = (uint32_t)NoResourceId;
    //loadInfo.resourcePath;
    if (isValidIndex(tex.name)) {
      loadInfo->resourceName = getString(rctx, tex.name).to_string();
    }
    loadInfo->resourceData.assign(bufferData, bufferData + tex.size);
    //loadInfo.resourceFlags;
    //loadInfo.handle;
    loadInfo->format = getTextureFormat(rctx, tex.format);
    loadInfo->target = Cogs::ResourceDimensions::Texture2D;
    loadInfo->width = static_cast<int>(tex.width);
    loadInfo->height = static_cast<int>(tex.height);
    loadInfo->depth = static_cast<int>(tex.depth);
    loadInfo->stride = 0;
    //loadInfo.flip = 0;
 
    auto handle = rctx.context->textureManager->loadTexture(loadInfo);
 
    rctx.textureCache[textureIx] = handle;
 
    return handle;
  }
 
  MaterialInstanceHandle populateMaterialInstance(ReadContext& rctx, uint32_t materialInstanceIx)
  {
    const auto & srcMaterialInstance = rctx.materialInstances[materialInstanceIx];
    if (!isValidIndex(srcMaterialInstance.material)) {
      LOG_ERROR(logger, "Material instance without material.");
      rctx.success = false;
      return MaterialInstanceHandle::NoHandle;
    }
 
    auto materialName = getString(rctx, srcMaterialInstance.material);
    if (materialName.empty()) {
      LOG_ERROR(logger, "Writer should not include empty strings.");
      rctx.success = false;
      return MaterialInstanceHandle::NoHandle;
    }
 
    auto materialTemplate = rctx.context->materialManager->getMaterial(materialName);
    if (!materialTemplate) {
      LOG_ERROR(logger, "Invalid material template %.*s", StringViewFormat(materialName));
      rctx.success = false;
      return MaterialInstanceHandle::NoHandle;
    }
    //LOG_DEBUG(logger, "Instancing material %.*s:", StringViewFormat(materialName));
 
    auto material = rctx.context->materialInstanceManager->createMaterialInstance(materialTemplate);
 
    if (isValidIndex(srcMaterialInstance.permutation)) {
      material->setPermutation(getString(rctx, srcMaterialInstance.permutation));
    }
 
    for (uint32_t i = 0; i < srcMaterialInstance.propertyCount; i++) {
      if (rctx.props.count <= srcMaterialInstance.propertyFirst + i) {
        LOG_ERROR(logger, "Invalid property index.");
        rctx.success = false;
        return MaterialInstanceHandle::NoHandle;
      }
 
      auto & prop = rctx.props[srcMaterialInstance.propertyFirst + i];
      switch (prop.keyType) {
      case CogsBin3::PropertyKeyType::Index:
        assert(false && "FIXME");
        break;
 
      case CogsBin3::PropertyKeyType::String: {
 
        auto keyString = getString(rctx, prop.key);
        switch (prop.valueType) {
 
        case CogsBin3::PropertyValueType::Bool:
          if (auto key = materialTemplate->getBoolKey(keyString); key != NoProperty)
            material->setBoolProperty(key, getPropertyValue<uint32_t>(rctx, prop));
          else
            LOG_ERROR(logger, "Invalid bool key %.*s", StringViewFormat(keyString));
          break;
 
        case CogsBin3::PropertyValueType::UInt:
          if (auto key = materialTemplate->getUIntKey(keyString); key != NoProperty)
            material->setUIntProperty(key, getPropertyValue<uint32_t>(rctx, prop));
          else
            LOG_ERROR(logger, "Invalid uint key %.*s", StringViewFormat(keyString));
          break;
 
        case CogsBin3::PropertyValueType::Float:
          if (auto key = materialTemplate->getFloatKey(keyString); key != NoProperty)
            material->setFloatProperty(key, getPropertyValue<float>(rctx, prop));
          else
            LOG_ERROR(logger, "Invalid float key %.*s", StringViewFormat(keyString));
          break;
 
        case CogsBin3::PropertyValueType::Float2:
          if (auto key = materialTemplate->getVec2Key(keyString); key != NoProperty)
            material->setVec2Property(key, getPropertyValue<glm::vec2>(rctx, prop));
          else
            LOG_ERROR(logger, "Invalid float2 key %.*s", StringViewFormat(keyString));
          break;
 
        case CogsBin3::PropertyValueType::Float3:
          if (auto key = materialTemplate->getVec3Key(keyString); key != NoProperty)
            material->setVec3Property(key, getPropertyValue<glm::vec3>(rctx, prop));
          else
            LOG_ERROR(logger, "Invalid float3 key %.*s", StringViewFormat(keyString));
          break;
 
        case CogsBin3::PropertyValueType::Float4:
          if (auto key = materialTemplate->getVec4Key(keyString); key != NoProperty)
            material->setVec4Property(key, getPropertyValue<glm::vec4>(rctx, prop));
          else
            LOG_ERROR(logger, "Invalid float4 key %.*s", StringViewFormat(keyString));
          break;
 
        case CogsBin3::PropertyValueType::String:
          if (auto key = materialTemplate->getTextureKey(keyString); key != NoProperty) {
            auto textureFlags = TextureLoadFlags::None;
            if (const auto & mprop = materialTemplate->textureProperties[key]; ((int)mprop.flags & (int)MaterialPropertyFlags::sRGB) == 0) {
              textureFlags |= TextureLoadFlags::LinearColorSpace;
            }
            std::string sourcePath = getString(rctx, prop.value).to_string();
            if (Cogs::IO::isRelative(sourcePath)) {
              sourcePath = Cogs::IO::combine(Cogs::IO::parentPath(rctx.path), sourcePath);
            }
            auto texture = rctx.context->textureManager->loadTexture(sourcePath, NoResourceId, textureFlags);
            material->setTextureProperty(key, texture);
          }
          else
            LOG_ERROR(logger, "Invalid float4 key %.*s", StringViewFormat(keyString));
          break;
 
        case CogsBin3::PropertyValueType::Variant: {
          auto key = getString(rctx, prop.key);
          auto val = getString(rctx, prop.value);
          if (materialName == "DefaultMaterial" && key == "NormalMap") {
            key = "TangentSpaceNormalMap";
          }
          material->setVariant(key, val);
          //LOG_DEBUG(logger, "Variant %.*s=%.*s",
          //          StringViewFormat(key),
          //          StringViewFormat(val));
          break;
        }
        case CogsBin3::PropertyValueType::EmbeddedTexture:
          if (auto key = materialTemplate->getTextureKey(keyString); key != NoProperty) {
            auto textureIx = getPropertyValue<uint32_t>(rctx, prop);
            auto texture = populateEmbeddedTexture(rctx, textureIx);
            material->setTextureProperty(key, texture);
          }
          break;
 
        default:
          LOG_ERROR(logger, "Invalid property value type.");
          rctx.success = false;
          return MaterialInstanceHandle::NoHandle;
        }
        break;
      }
      default:
        LOG_ERROR(logger, "Invalid property key type.");
        rctx.success = false;
        return MaterialInstanceHandle::NoHandle;
      }
    }
    return material;
 
  }
 
  template<typename ResourceProxy>
  void populatePart(ReadContext& rctx, ResourceProxy& model, ModelPart& part, const CogsBin3::Node& node)
  {
    // parentIndex is populated by caller
 
    if (isValidIndex(node.boundingBox)) {
      part.boundsIndex = uint32_t(model->bounds.size());
      model->bounds.emplace_back(getBoundingBox(rctx, node.boundingBox));
    }
    if (isValidIndex(node.transform)) {
      const auto * m = rctx.transforms[node.transform].m;
      model->setPartTransform(part, glm::mat4(m[0], m[1], m[2], 0.f,
                                              m[3], m[4], m[5], 0.f,
                                              m[6], m[7], m[8], 0.f,
                                              m[9], m[10], m[11], 1.f));
    }
    if (isValidIndex(node.name)) {
      model->setPartName(part, getString(rctx, node.name));
    }
    if (isValidIndex(node.mesh)) {
      part.meshIndex = uint32_t(model->meshes.size());
      model->meshes.emplace_back(rctx.context->meshManager->create());
      if (rctx.group != NoTask) {
        rctx.context->taskManager->enqueueChild(rctx.group, [rc = &rctx, h = model->meshes.back(), ix = node.mesh](){populateMesh(*rc, h, ix); });
      }
      else {
        populateMesh(rctx, model->meshes.back(), node.mesh);
      }
    }
    if (isValidIndex(node.materialInstance)) {
      part.materialIndex = uint32_t(model->materials.size());
      model->materials.emplace_back(populateMaterialInstance(rctx, node.materialInstance));
    }
    if (node.primitiveType != CogsBin3::PrimitiveType::Unknown) {
      part.primitiveType = translatePrimitiveType(rctx, node.primitiveType);
    } else {
      part.primitiveType = (uint32_t)-1;
    }
    part.startIndex = node.vertexFirst;
    part.vertexCount = node.vertexCount;
  }
 
  void populateBone(ReadContext& rctx, Bone& dstBone, const uint32_t boneIx, const uint32_t boneCount)
  {
    if (rctx.bones.count <= boneIx) {
      LOG_ERROR(logger, "Invalid bone index %u (bone count is %zu)", boneIx, rctx.bones.count);
      rctx.success = false;
      return;
    }
    const auto & srcBone = rctx.bones[boneIx];
    dstBone.name = getString(rctx, srcBone.name).to_string();
    if (isValidIndex(srcBone.parentBone)) {
      if (boneCount <= srcBone.parentBone) {
        LOG_ERROR(logger, "Invalid parent bone index %u (skeleton bone count is %u)", unsigned(srcBone.parentBone), boneCount);
        rctx.success = false;
        return;
      }
      dstBone.parentBone = srcBone.parentBone;
    }
    else {
      dstBone.parentBone = (size_t)-1;
    }
    dstBone.pos = srcBone.pos;
    dstBone.scale = srcBone.scale;
    dstBone.rot = srcBone.rot;
    dstBone.relative = srcBone.relative;
    dstBone.inverseBindPose = srcBone.inverseBindPose;
    dstBone.hasOffset = (srcBone.flags & CogsBin3::BoneFlags::HasOffset) != 0;
    dstBone.used = (srcBone.flags & CogsBin3::BoneFlags::Used) != 0;
    dstBone.animated = (srcBone.flags & CogsBin3::BoneFlags::Animated) != 0;
  }
 
  void populateSkeleton(ReadContext& rctx, Skeleton& dstSkeleton, const uint32_t skeletonIx)
  {
    if (rctx.skeletons.count <= skeletonIx) {
      LOG_ERROR(logger, "Invalid skeleton index %u (skeleton count is %zu)", skeletonIx, rctx.skeletons.count);
      rctx.success = false;
      return;
    }
    const auto & srcSkeleton = rctx.skeletons[skeletonIx];
    dstSkeleton.bindPose = srcSkeleton.bindPose;
    dstSkeleton.bones.resize(srcSkeleton.boneCount);
    for (uint32_t i = 0; i < srcSkeleton.boneCount && rctx.success; i++) {
      populateBone(rctx, dstSkeleton.bones[i], srcSkeleton.firstBone + i, srcSkeleton.boneCount);
      dstSkeleton.bonesByName[dstSkeleton.bones[i].name] = i;
    }
    updateSkeletonPose(dstSkeleton);
  }
 
  void populateAnimTrack(ReadContext& rctx, AnimationTrack& dstTrack, const uint32_t animTrackIx)
  {
    assert(animTrackIx < rctx.animTracks.count);
    const auto & srcTrack = rctx.animTracks[animTrackIx];
 
    assert(srcTrack.buffer < rctx.buffers.count);
    const auto & buffer = rctx.buffers[srcTrack.buffer];
    const auto * bufferData = resolveDataOffset(rctx, buffer.sectionOffset, buffer.size);
 
    dstTrack.boneIndex = isValidIndex(srcTrack.boneIndex) ? srcTrack.boneIndex : -1;
 
    const auto * translationSrc = (const float*)(bufferData + srcTrack.translationOffset);
    dstTrack.translations.resize(srcTrack.translationCount);
    for (unsigned i = 0; i < srcTrack.translationCount; i++) {
      dstTrack.translations[i].t = *translationSrc++;
      dstTrack.translations[i].value[0] = *translationSrc++;
      dstTrack.translations[i].value[1] = *translationSrc++;
      dstTrack.translations[i].value[2] = *translationSrc++;
    }
 
    const auto * rotationSrc = (const float*)(bufferData + srcTrack.rotationOffset);
    dstTrack.rotations.resize(srcTrack.rotationCount);
    for (unsigned i = 0; i < srcTrack.rotationCount; i++) {
      dstTrack.rotations[i].t = *rotationSrc++;
      dstTrack.rotations[i].value[0] = *rotationSrc++;
      dstTrack.rotations[i].value[1] = *rotationSrc++;
      dstTrack.rotations[i].value[2] = *rotationSrc++;
      dstTrack.rotations[i].value[3] = *rotationSrc++;
    }
 
    const auto * scaleSrc = (const float*)(bufferData + srcTrack.scaleOffset);
    dstTrack.scales.resize(srcTrack.scaleCount);
    for (unsigned i = 0; i < srcTrack.scaleCount; i++) {
      dstTrack.scales[i].t = *scaleSrc++;
      dstTrack.scales[i].value[0] = *scaleSrc++;
      dstTrack.scales[i].value[1] = *scaleSrc++;
      dstTrack.scales[i].value[2] = *scaleSrc++;
    }
  }
 
  void populateAnimClip(ReadContext& rctx, AnimationClip& dstClip, const uint32_t animClipIx)
  {
    if (rctx.animClips.count <= animClipIx) {
      LOG_ERROR(logger, "Invalid animation clip index %u (animation clip count is %zu)", animClipIx, rctx.animClips.count);
      rctx.success = false;
      return;
    }
    const CogsBin3::AnimClip& srcClip = rctx.animClips[animClipIx];
    dstClip.name = getString(rctx, srcClip.name).to_string();
    dstClip.duration = srcClip.duration;
    dstClip.resolution = srcClip.resolution;
    dstClip.tracks.resize(srcClip.trackCount);
    for (unsigned i = 0; i < srcClip.trackCount && rctx.success; i++) {
      populateAnimTrack(rctx, dstClip.tracks[i], srcClip.trackFirst + i);
    }
  }
 
  void populateModel(ReadContext& rctx, ResourceHandleBase modelHandle, const uint32_t modelIx)
  {
    const auto & srcModel = rctx.models[modelIx];
    if (srcModel.nodeCount == 0) return;
 
    assert(modelHandle && "Model handle without resource");
    auto dstModel = rctx.context->modelManager->lock(modelHandle);
    assert(dstModel->parts.empty() && "Destination model is not empty");
 
    // Populate skeleton
    if (isValidIndex(srcModel.skeleton)) populateSkeleton(rctx, dstModel->skeleton, srcModel.skeleton);
 
    // Populate animation
    if (srcModel.animClipCount != 0) {
      dstModel->animation = rctx.context->animationManager->create();
 
      auto * anim = dstModel->animation.resolve();
      anim->skeleton = dstModel->skeleton;               // use model skeleton as animation skeleton.
      anim->clips.resize(srcModel.animClipCount);
      for (uint32_t i = 0; i < srcModel.animClipCount && rctx.success; i++) {
        populateAnimClip(rctx, anim->clips[i], srcModel.animClipFirst + i);
        anim->clipsByName[anim->clips[i].name] = i;
      }
    }
 
    // Populate parts
    dstModel->parts.resize(srcModel.nodeCount);
    for (size_t i = 0; i < srcModel.nodeCount && rctx.success; i++) {
      if (!isValidIndex(srcModel.firstNode) || rctx.nodes.count <= srcModel.firstNode + i) {
        LOG_ERROR(logger, "Invalid node index %u (node count is %zu)", srcModel.firstNode, rctx.nodes.count);
        rctx.success = false;
        return;
      }
      const auto & node = rctx.nodes[srcModel.firstNode + i];
      auto & part = dstModel->parts[i];
      if (!isValidIndex(node.parent)) {
        part.parentIndex = ~0u;
      }
      else if (node.parent < srcModel.firstNode || srcModel.firstNode + srcModel.nodeCount <= node.parent) {
        LOG_ERROR(logger, "Illegal parent node index %u (node count is %zu)", node.parent, rctx.nodes.count);
        rctx.success = false;
        return;
      }
      else {
        part.parentIndex = node.parent - srcModel.firstNode;
      }
      populatePart(rctx, dstModel, part, node);
    }
  }
 
 
}
 
bool Cogs::Core::loadCogsBin3(Context * context, const ModelLoadInfo & loadInfo, std::unique_ptr<Cogs::FileContents> contents_)
{
  if (!contents_ || contents_->size < sizeof(CogsBin3::Header)) return false;
 
  ReadContext rctx;
  rctx.context = context;
  rctx.contents = std::move(contents_);
 
  if (loadCount.fetch_add(1) < COGS_MODELLOADER_MAX_TASKS) {
    rctx.group = context->taskManager->createGroup(TaskManager::ResourceQueue);
  }
  rctx.path = loadInfo.resourcePath;
  rctx.success = true;
 
  unsigned modelIx = 0u;
  if (auto i = rctx.path.find('#'); i != std::string::npos) {
    if (i + 1 < rctx.path.length()) {
      modelIx = std::atoi(rctx.path.c_str() + i + 1);
    }
    rctx.path.resize(i);
  }
 
  if (rctx.contents->size < sizeof(CogsBin3::Header)) {
    LOG_ERROR(logger, "Model file too small to contain a header, unable to load.");
    return false;
  }
 
  rctx.header = (CogsBin3::Header *)rctx.contents->ptr;
  if (rctx.header->sectionCount == 0) {
    LOG_ERROR(logger, "No sections in file.");
    return false;
  }
  if (rctx.header->fileLength != rctx.contents->size) {
    LOG_ERROR(logger, "File size mismatch in read context, potentially corrupt or truncated model file.");
    return false;
  }
 
  rctx.sectionInfo = std::span<CogsBin3::SectionInfo>((CogsBin3::SectionInfo*)(rctx.contents->ptr + sizeof(CogsBin3::Header)),
                                                      (CogsBin3::SectionInfo*)(rctx.contents->ptr + sizeof(CogsBin3::Header)) + rctx.header->sectionCount);
  rctx.sectionPtr.resize(rctx.header->sectionCount);
  rctx.sectionLocks.reset(new Cogs::Mutex[rctx.header->sectionCount]);
 
  LOG_TRACE(logger, "Parsed header, %u sections, filesize=%zu", rctx.header->sectionCount, rctx.contents->size);
 
 
  if ((rctx.sectionInfo[0].type & CogsBin3::SectionType::META) == 0) {
    LOG_ERROR(logger, "First section is not a meta section.");
    return false;
  }
 
  const auto * sectionBase = sectionPointer(rctx, 0);
  if (sectionBase == nullptr) return false;
 
  for (uint16_t sub = 0; sub < rctx.sectionInfo[0].subSectionCount; sub++) {
    const auto & metaSubSection = ((CogsBin3::SubSectionInfo*)sectionBase)[sub];
    switch (metaSubSection.type)
    {
    case CogsBin3::SubSectionType::Buffers:
      rctx.buffers.base = (const CogsBin3::Buffer*)(sectionBase + metaSubSection.offset);
      rctx.buffers.count = metaSubSection.size / sizeof(CogsBin3::Buffer);
      rctx.bufferCache.resize(rctx.buffers.count);
      //LOG_DEBUG(logger, "Found %zu buffers.", rctx.buffers.count);
      break;
    case CogsBin3::SubSectionType::Textures:
      rctx.textures.base = (const CogsBin3::Texture*)(sectionBase + metaSubSection.offset);
      rctx.textures.count = metaSubSection.size / sizeof(CogsBin3::Texture);
      rctx.textureCache.resize(rctx.textures.count);
      //LOG_DEBUG(logger, "Found %zu textures.", rctx.textures.count);
      break;
    case CogsBin3::SubSectionType::Strings:
      rctx.strings.base = (const CogsBin3::String*)(sectionBase + metaSubSection.offset);
      rctx.strings.count = metaSubSection.size / sizeof(CogsBin3::String);
      //LOG_DEBUG(logger, "Found %zu strings.", rctx.strings.count);
      break;
    case CogsBin3::SubSectionType::StringData:
      rctx.stringData.base = (char*)(sectionBase + metaSubSection.offset);
      rctx.stringData.count = metaSubSection.size;
      //LOG_DEBUG(logger, "Found %zu stringData bytes.", rctx.stringData.count);
      break;
    case CogsBin3::SubSectionType::Nodes:
      rctx.nodes.base = (const CogsBin3::Node*)(sectionBase + metaSubSection.offset);
      rctx.nodes.count = metaSubSection.size / sizeof(CogsBin3::Node);
      //LOG_DEBUG(logger, "Found %zu nodes.", rctx.nodes.count);
      break;
    case CogsBin3::SubSectionType::Transforms:
      rctx.transforms.base = (const CogsBin3::Transform*)(sectionBase + metaSubSection.offset);
      rctx.transforms.count = metaSubSection.size / sizeof(CogsBin3::Transform);
      //LOG_DEBUG(logger, "Found %zu transforms.", rctx.transforms.count);
      break;
    case CogsBin3::SubSectionType::BoundingBoxes:
      rctx.boundingBoxes.base = (const Cogs::Geometry::BoundingBox*)(sectionBase + metaSubSection.offset);
      rctx.boundingBoxes.count = metaSubSection.size / sizeof(Cogs::Geometry::BoundingBox);
      //LOG_DEBUG(logger, "Found %zu bounding boxes.", rctx.boundingBoxes.count);
      break;
    case CogsBin3::SubSectionType::MaterialInstances:
      rctx.materialInstances.base = (const CogsBin3::MaterialInstance*)(sectionBase + metaSubSection.offset);
      rctx.materialInstances.count = metaSubSection.size / sizeof(CogsBin3::MaterialInstance);
      //LOG_DEBUG(logger, "Found %zu material instances.", rctx.materialInstances.count);
      break;
    case CogsBin3::SubSectionType::Properties:
      rctx.props.base = (const CogsBin3::Property*)(sectionBase + metaSubSection.offset);
      rctx.props.count = metaSubSection.size / sizeof(CogsBin3::Property);
      //LOG_DEBUG(logger, "Found %zu properties.", rctx.props.count);
      break;
    case CogsBin3::SubSectionType::PropertyData:
      rctx.propData.base = sectionBase + metaSubSection.offset;
      rctx.propData.count = metaSubSection.size;
      //LOG_DEBUG(logger, "Found %zu propData bytes.", rctx.propData.count);
      break;
    case CogsBin3::SubSectionType::Meshes:
      rctx.meshes.base = (const CogsBin3::Mesh*)(sectionBase + metaSubSection.offset);
      rctx.meshes.count = metaSubSection.size / sizeof(CogsBin3::Mesh);
      //LOG_DEBUG(logger, "Found %zu meshes.", rctx.meshes.count);
      break;
    case CogsBin3::SubSectionType::VertexStreams:
      rctx.vertexStreams.base = (const CogsBin3::VertexStream*)(sectionBase + metaSubSection.offset);
      rctx.vertexStreams.count = metaSubSection.size / sizeof(CogsBin3::VertexStream);
      //LOG_DEBUG(logger, "Found %zu vertex streams.", rctx.vertexStreams.count);
      break;
    case CogsBin3::SubSectionType::VertexAttributes:
      rctx.vertexAttributes.base = (const CogsBin3::VertexAttribute*)(sectionBase + metaSubSection.offset);
      rctx.vertexAttributes.count = metaSubSection.size / sizeof(CogsBin3::VertexAttribute);
      //LOG_DEBUG(logger, "Found %zu vertex attributes.", rctx.vertexAttributes.count);
      break;
    case CogsBin3::SubSectionType::Bones:
      rctx.bones.base = (const CogsBin3::Bone*)(sectionBase + metaSubSection.offset);
      rctx.bones.count = metaSubSection.size / sizeof(CogsBin3::Bone);
      //LOG_DEBUG(logger, "Found %zu bones.", rctx.bones.count);
      break;
    case CogsBin3::SubSectionType::Skeletons:
      rctx.skeletons.base = (const CogsBin3::Skeleton*)(sectionBase + metaSubSection.offset);
      rctx.skeletons.count = metaSubSection.size / sizeof(CogsBin3::Skeleton);
      //LOG_DEBUG(logger, "Found %zu skeletons.", rctx.skeletons.count);
      break;
    case CogsBin3::SubSectionType::AnimTracks:
      rctx.animTracks.base = (const CogsBin3::AnimTrack*)(sectionBase + metaSubSection.offset);
      rctx.animTracks.count = metaSubSection.size / sizeof(CogsBin3::AnimTrack);
      //LOG_DEBUG(logger, "Found %zu anim tracks.", rctx.animTracks.count);
      break;
    case CogsBin3::SubSectionType::AnimClips:
      rctx.animClips.base = (const CogsBin3::AnimClip*)(sectionBase + metaSubSection.offset);
      rctx.animClips.count = metaSubSection.size / sizeof(CogsBin3::AnimClip);
      //LOG_DEBUG(logger, "Found %zu anim clips.", rctx.animClips.count);
      break;
    case CogsBin3::SubSectionType::Models:
      rctx.models.base = (const CogsBin3::Model*)(sectionBase + metaSubSection.offset);
      rctx.models.count = metaSubSection.size / sizeof(CogsBin3::Model);
      //LOG_DEBUG(logger, "Found %zu models.", rctx.models.count);
      break;
    default:
      LOG_ERROR(logger, "Unknown subsection type %u", unsigned(metaSubSection.type));
    }
  }
 
  // Try to detect problems upfront gracefully
  for (uint32_t i = 0; i < rctx.buffers.count; i++) {
    const auto & buffer = rctx.buffers[i];
    const auto sectionIx = buffer.sectionOffset >> 48;
    const auto sectionOffset = size_t(buffer.sectionOffset & 0xFFFFFFFFFFFFull);
    if (rctx.header->sectionCount <= sectionIx) {
      LOG_ERROR(logger, "Illegal section index %u (section count is %u)", unsigned(sectionIx), rctx.header->sectionCount);
      return false;
    }
    const auto & sectionInfo = rctx.sectionInfo[sectionIx];
    if (sectionInfo.uncompressedSize < sectionOffset + buffer.size) {
      LOG_ERROR(logger, "Buffer out of bounds");
      return false;
    }
  }
 
  for (uint32_t i = 0; i < rctx.textures.count; i++) {
    const auto & tex = rctx.textures[i];
    if (rctx.buffers.count <= tex.buffer) { LOG_ERROR(logger, "Texture has illegal buffer index %u", tex.buffer); return false; }
    auto & buf = rctx.buffers[tex.buffer];
    if (buf.size < tex.offset + tex.size) { LOG_ERROR(logger, "Texture buffer view outside buffer"); return false; }
    if (isValidIndex(tex.name) && rctx.strings.count <= tex.name) { LOG_ERROR(logger, "Illegal name string %u", tex.name); return false; }
    if (0x10000 < tex.width) { LOG_ERROR(logger, "Suspicious texture width %u", tex.width); return false; }
    if (0x10000 < tex.height) { LOG_ERROR(logger, "Suspicious texture height %u", tex.height); return false; }
    if (0x10000 < tex.depth) { LOG_ERROR(logger, "Suspicious texture depth %u", tex.depth); return false; }
    if (6 < tex.faces) { LOG_ERROR(logger, "Suspicious texture faces %u", tex.faces); return false; }
    if (0x10000 < tex.layers) { LOG_ERROR(logger, "Suspicious texture layers %u", tex.layers); return false; }
    if (CogsBin3::Format::EnumSize <= tex.format) { LOG_ERROR(logger, "Illegal format %u", unsigned(tex.format)); return false; }
    if (CogsBin3::TextureEncoding::EnumSize <= tex.encoding) { LOG_ERROR(logger, "Illegal encoding %u", unsigned(tex.encoding)); return false; }
  }
 
  for (uint32_t i = 0; i < rctx.vertexStreams.count; i++) {
    const auto & dataStream = rctx.vertexStreams[i];
    if (rctx.buffers.count <= dataStream.buffer) {
      LOG_ERROR(logger, "Vertex stream has illegal buffer index %u (count is %zu)", dataStream.buffer, rctx.buffers.count);
      return false;
    }
    if (dataStream.vertexDataType < VertexDataType::LastVertexType) {
      if (!isValidIndex(dataStream.firstAttribute)) {
        LOG_ERROR(logger, "Vertex stream without attributes");
        return false;
      }
      if (rctx.vertexAttributes.count <= dataStream.firstAttribute || rctx.vertexAttributes.count < dataStream.firstAttribute + dataStream.attributeCount) {
        LOG_ERROR(logger, "Vertex stream has illegal vertex attribute indices first=%u count=%u (total count is %zu)",
                  dataStream.firstAttribute, dataStream.attributeCount, rctx.vertexAttributes.count);
        return false;
      }
    } else if (dataStream.vertexDataType == VertexDataType::Indexes) {
      if (dataStream.stride != 4 && dataStream.stride != 2) {
        LOG_ERROR(logger, "Index stream has unsupported stride.");
        return false;
      }
    }
 
    if (!isValidIndex(dataStream.buffer)) {
      LOG_ERROR(logger, "Data stream without valid buffer.");
      return false;
    }
  }
 
  for (uint32_t i = 0; i < rctx.animTracks.count; i++) {
    const auto & track = rctx.animTracks[i];
    if (kMaxBones <= track.boneIndex) {
      LOG_ERROR(logger, "Anim track has illegal bone index %u (kMaxBones is %zu)", track.boneIndex, kMaxBones);
      return false;
    }
    if (rctx.buffers.count <= track.buffer) {
      LOG_ERROR(logger, "Anim track has illegal buffer index %u.", track.buffer);
      return false;
    }
    const auto & buffer = rctx.buffers[track.buffer];
    if (buffer.size < track.translationOffset + 4 * sizeof(float)*track.translationCount) {
      LOG_ERROR(logger, "Anim track translation buffer view is outside buffer.");
      return false;
    }
    if (buffer.size < track.rotationOffset + 5 * sizeof(float)*track.rotationCount) {
      LOG_ERROR(logger, "Anim track translation buffer view is outside buffer.");
      return false;
    }
    if (buffer.size < track.scaleOffset + 4 * sizeof(float)*track.scaleCount) {
      LOG_ERROR(logger, "Anim track translation buffer view is outside buffer.");
      return false;
    }
  }
 
  for (uint32_t i = 0; i < rctx.meshes.count; i++) {
    const auto & mesh = rctx.meshes[i];
    if (isValidIndex(mesh.name) && rctx.strings.count <= mesh.name) {
      LOG_ERROR(logger, "Mesh name has illegal string index %u (string count is %zu)", mesh.name, rctx.strings.count);
      return false;
    }
    if (isValidIndex(mesh.boundingBox) && rctx.boundingBoxes.count <= mesh.boundingBox) {
      LOG_ERROR(logger, "Mesh name has illegal boundingBox index %u (count is %zu)", mesh.boundingBox, rctx.boundingBoxes.count);
      return false;
    }
    if (isValidIndex(mesh.firstStream) && rctx.vertexStreams.count <= mesh.firstStream) {
      LOG_ERROR(logger, "Mesh name has illegal data stream index %u (count is %zu)", mesh.firstStream, rctx.vertexStreams.count);
      return false;
    }
  }
 
  if (modelIx < rctx.models.count) {
    populateModel(rctx, loadInfo.handle, modelIx);
  }
  else {
    LOG_ERROR(logger, "Invalid model index %u (model count=%zu)", modelIx, rctx.models.count);
    rctx.success = false;
  }
 
  if (rctx.group != NoTask) {
    // wait here before we release the memory mapping.
    context->taskManager->wait(rctx.group);
  }
  loadCount--;
 
  return rctx.success;
}
 
// #pragma optimize( "", on )