CogsBin3Writer.cpp

#include "ModelWriter.h"
#include "Context.h"
#include "CogsBin3.h"
 
#include "Components/Core/TransformComponent.h"
#include "Components/Core/SceneComponent.h"
#include "Components/Core/AnimationComponent.h"
#include "Components/Core/MeshComponent.h"
#include "Components/Core/MeshRenderComponent.h"
 
#include "Systems/Core/TransformSystem.h"
#include "Systems/Core/RenderSystem.h"
 
#include "Resources/Buffer.h"
#include "Resources/Mesh.h"
#include "Resources/MaterialInstance.h"
#include "Resources/Texture.h"
#include "Resources/Model.h"
#include "Resources/Animation.h"
 
#include "Resources/DefaultMaterial.h"
 
#include "Foundation/HashSequence.h"
#include "Foundation/Logging/Logger.h"
#include "Foundation/Platform/IO.h"
#include "Foundation/Platform/Timer.h"
 
#include "zstd.h"
#include "stb_image_write.h"
 
#include <map>
#include <stdio.h>
 
#ifndef EMSCRIPTEN
 
//#define MAKE_DEBUGABLE
 
#if defined(_WIN32) && defined(MAKE_DEBUGABLE)
#pragma optimize( "", off )
#endif
 
using namespace Cogs::Geometry;
 
namespace
{
  using namespace Cogs::Core;
 
  const Cogs::Logging::Log logger = Cogs::Logging::getLogger("CogsBin3Writer");
 
 
  template<typename T>
  uint32_t nextIndex(T& t)
  {
    auto ix = t.size();
    if (static_cast<size_t>(std::numeric_limits<uint32_t>::max()) < ix) {
      LOG_ERROR(logger, "Index out of range. Model data too large.");
    }
 
    return static_cast<uint32_t>(ix);
  }
 
  struct WSubSection
  {
    uint64_t                  offset;
    uint32_t                  size;
    CogsBin3::SubSectionType  type;
  };
 
  struct WSection
  {
    CogsBin3::SectionType type;
    uint32_t              index;
    uint64_t              writePos;
    uint64_t              dataSize;       // # bytes of data not in a subsection.
    std::vector<uint8_t>  contents;
    std::vector<WSubSection> subSections;
  };
 
  struct WVertexFormatRec
  {
    const Cogs::VertexFormat* format;
    uint32_t index;
  };
 
  struct WBufferContext
  {
    Cogs::Memory::MemoryBuffer  contents;
    uint32_t                    alignment = 0;
  };
 
  struct WriteContext
  {
    uint32_t numVertes = 0;
    uint32_t numIndexes = 0;
    std::string fileName;
    WriteModelSettings settings;
    WriteModelFlags flags = WriteModelFlags::NONE;
 
    Animation* currentAnimation = nullptr;
 
    std::vector<std::unique_ptr<WSection>> sections;         // FIXME: use a more clever container. unique ptr so mem refs is not invalidated by resizes.
 
    std::vector<const TranslationKey*> animTrackTranslateSource;
    std::vector<const RotationKey*> animTrackRotationSource;
    std::vector<const ScaleKey*> animTrackScaleSource;
    std::vector<WBufferContext> bufferContexts;
 
    std::vector<uint8_t> stringData;
    std::vector<uint8_t> propertyData;
    std::vector<Cogs::Core::CogsBin3::Buffer> buffers;
    std::vector<Cogs::Core::CogsBin3::Texture> textures;
    std::vector<Cogs::Core::CogsBin3::String> strings;
    std::vector<Cogs::Core::CogsBin3::Property> properties;
    std::vector<Cogs::Core::CogsBin3::MaterialInstance> materialInstances;
    std::vector<Cogs::Core::CogsBin3::Transform> transforms;
    std::vector<Cogs::Geometry::BoundingBox> boundingBoxes;
    std::vector<Cogs::Core::CogsBin3::Node> nodes;
    std::vector<Cogs::Core::CogsBin3::Mesh> meshes;
    std::vector<Cogs::Core::CogsBin3::VertexStream> vertexStreams;
    std::vector<Cogs::Core::CogsBin3::VertexAttribute> vertexAttributes;
    std::vector<Cogs::Core::CogsBin3::Bone> bones;
    std::vector<Cogs::Core::CogsBin3::Skeleton> skeletons;
    std::vector<Cogs::Core::CogsBin3::Model> models;
    std::vector<Cogs::Core::CogsBin3::AnimTrack> animTracks;
    std::vector<Cogs::Core::CogsBin3::AnimClip> animClips;
 
    std::vector<CogsBin3::SectionInfo>  sectionInfos;
 
    std::map<const Cogs::Core::Texture*, uint32_t> knownTexturesByPointer;
    std::map<const Cogs::Core::MaterialInstance*, uint32_t> knownMaterialInstancesByPointer;
    std::map<size_t, uint32_t> knownMaterialInstancesByHash;
    std::map<size_t, uint32_t> propByHash;
    std::map<size_t, uint32_t> stringByHash;
    std::map<size_t, uint32_t> transformByHash;
    std::map<size_t, uint32_t> boundingBoxByHash;
    std::map<const Cogs::Core::Mesh*, uint32_t> meshByPointer;
    std::map<const Cogs::Core::BufferResource*, uint32_t> bufferByPointer;
    std::map<size_t, WVertexFormatRec> vertexFormatByHash;
  };
 
  template<typename T, typename S>
  T checkedCast(const S v)
  {
    assert(v <= std::numeric_limits<T>::max());
    return T(v);
  }
 
  inline uint64_t align(uint64_t x)
  {
    const uint64_t m = CogsBin3::CogsSectionAlignment - 1;
    return (x + m) & ~m;
  }
 
  CogsBin3::PrimitiveType translatePrimitiveType(WriteContext& /*wctx*/, Cogs::PrimitiveType::EPrimitiveType primitiveType)
  {
    switch (primitiveType) {
    case Cogs::PrimitiveType::TriangleList:           return CogsBin3::PrimitiveType::TriangleList; break;
    case Cogs::PrimitiveType::TriangleStrip:          return CogsBin3::PrimitiveType::TriangleStrip; break;
    case Cogs::PrimitiveType::LineList:               return CogsBin3::PrimitiveType::LineList; break;
    case Cogs::PrimitiveType::LineStrip:              return CogsBin3::PrimitiveType::LineStrip; break;
    case Cogs::PrimitiveType::PointList:              return CogsBin3::PrimitiveType::PointList; break;
    case Cogs::PrimitiveType::TriangleListAdjacency:  return CogsBin3::PrimitiveType::TriangleListAdjacency; break;
    case Cogs::PrimitiveType::TriangleStripAdjacency: return CogsBin3::PrimitiveType::TriangleStripAdjacency; break;
    case Cogs::PrimitiveType::LineListAdjacency:      return CogsBin3::PrimitiveType::LineListAdjacency; break;
    case Cogs::PrimitiveType::LineStripAdjacency:     return CogsBin3::PrimitiveType::LineStripAdjacency; break;
    case Cogs::PrimitiveType::ControlPoint1PatchList: return CogsBin3::PrimitiveType::ControlPoint1PatchList; break;
    case Cogs::PrimitiveType::ControlPoint2PatchList: return CogsBin3::PrimitiveType::ControlPoint2PatchList; break;
    case Cogs::PrimitiveType::ControlPoint3PatchList: return CogsBin3::PrimitiveType::ControlPoint3PatchList; break;
    case Cogs::PrimitiveType::ControlPoint4PatchList: return CogsBin3::PrimitiveType::ControlPoint4PatchList; break;
    default:
      break;
    }
    assert(false && "Illegal primitive type encountered");
    return CogsBin3::PrimitiveType::TriangleList;
  }
 
  CogsBin3::Format translateFormat(Cogs::TextureFormat format)
  {
    switch (format) {
    case Cogs::TextureFormat::Unknown:            return CogsBin3::Format::Unknown; break;
    case Cogs::TextureFormat::R8_UNORM:           return CogsBin3::Format::R8_UNORM; break;
    case Cogs::TextureFormat::R8G8_UNORM:         return CogsBin3::Format::R8G8_UNORM; break;
    case Cogs::TextureFormat::R8G8B8_UNORM:       return CogsBin3::Format::R8G8B8_UNORM; break;
    case Cogs::TextureFormat::R8G8B8A8_UNORM:     return CogsBin3::Format::R8G8B8A8_UNORM; break;
    case Cogs::TextureFormat::R16_UNORM:          return CogsBin3::Format::R16_UNORM; break;
    case Cogs::TextureFormat::R16G16_UNORM:       return CogsBin3::Format::R16G16_UNORM; break;
    case Cogs::TextureFormat::R16G16B16_UNORM:    return CogsBin3::Format::R16G16B16_UNORM; break;
    case Cogs::TextureFormat::R16G16B16A16_UNORM: return CogsBin3::Format::R16G16B16A16_UNORM; break;
    case Cogs::TextureFormat::R8_SNORM:           return CogsBin3::Format::R8_SNORM; break;
    case Cogs::TextureFormat::R8G8_SNORM:         return CogsBin3::Format::R8G8_SNORM; break;
    case Cogs::TextureFormat::R8G8B8_SNORM:       return CogsBin3::Format::R8G8B8_SNORM; break;
    case Cogs::TextureFormat::R8G8B8A8_SNORM:     return CogsBin3::Format::R8G8B8A8_SNORM; break;
    case Cogs::TextureFormat::R16_SNORM:          return CogsBin3::Format::R16_SNORM; break;
    case Cogs::TextureFormat::R16G16_SNORM:       return CogsBin3::Format::R16G16_SNORM; break;
    case Cogs::TextureFormat::R16G16B16_SNORM:    return CogsBin3::Format::R16G16B16_SNORM; break;
    case Cogs::TextureFormat::R16G16B16A16_SNORM: return CogsBin3::Format::R16G16B16A16_SNORM; break;
    case Cogs::TextureFormat::R8_UINT:            return CogsBin3::Format::R8_UINT; break;
    case Cogs::TextureFormat::R8G8_UINT:          return CogsBin3::Format::R8G8_UINT; break;
    case Cogs::TextureFormat::R8G8B8_UINT:        return CogsBin3::Format::R8G8B8_UINT; break;
    case Cogs::TextureFormat::R8G8B8A8_UINT:      return CogsBin3::Format::R8G8B8A8_UINT; break;
    case Cogs::TextureFormat::R16_UINT:           return CogsBin3::Format::R16_UINT; break;
    case Cogs::TextureFormat::R16G16_UINT:        return CogsBin3::Format::R16G16_UINT; break;
    case Cogs::TextureFormat::R16G16B16_UINT:     return CogsBin3::Format::R16G16B16_UINT; break;
    case Cogs::TextureFormat::R16G16B16A16_UINT:  return CogsBin3::Format::R16G16B16A16_UINT; break;
    case Cogs::TextureFormat::R32_UINT:           return CogsBin3::Format::R32_UINT; break;
    case Cogs::TextureFormat::R32G32_UINT:        return CogsBin3::Format::R32G32_UINT; break;
    case Cogs::TextureFormat::R32G32B32_UINT:     return CogsBin3::Format::R32G32B32_UINT; break;
    case Cogs::TextureFormat::R32G32B32A32_UINT:  return CogsBin3::Format::R32G32B32A32_UINT; break;
    case Cogs::TextureFormat::R8_SINT:            return CogsBin3::Format::R8_SINT; break;
    case Cogs::TextureFormat::R8G8_SINT:          return CogsBin3::Format::R8G8_SINT; break;
    case Cogs::TextureFormat::R8G8B8_SINT:        return CogsBin3::Format::R8G8B8_SINT; break;
    case Cogs::TextureFormat::R8G8B8A8_SINT:      return CogsBin3::Format::R8G8B8A8_SINT; break;
    case Cogs::TextureFormat::R16_SINT:           return CogsBin3::Format::R16_SINT; break;
    case Cogs::TextureFormat::R16G16_SINT:        return CogsBin3::Format::R16G16_SINT; break;
    case Cogs::TextureFormat::R16G16B16_SINT:     return CogsBin3::Format::R16G16B16_SINT; break;
    case Cogs::TextureFormat::R16G16B16A16_SINT:  return CogsBin3::Format::R16G16B16A16_SINT; break;
    case Cogs::TextureFormat::R32_SINT:           return CogsBin3::Format::R32_SINT; break;
    case Cogs::TextureFormat::R32G32_SINT:        return CogsBin3::Format::R32G32_SINT; break;
    case Cogs::TextureFormat::R32G32B32_SINT:     return CogsBin3::Format::R32G32B32_SINT; break;
    case Cogs::TextureFormat::R32G32B32A32_SINT:  return CogsBin3::Format::R32G32B32A32_SINT; break;
    case Cogs::TextureFormat::R16_FLOAT:          return CogsBin3::Format::R16_FLOAT; break;
    case Cogs::TextureFormat::R16G16_FLOAT:       return CogsBin3::Format::R16G16_FLOAT; break;
    case Cogs::TextureFormat::R16G16B16_FLOAT:    return CogsBin3::Format::R16G16B16_FLOAT; break;
    case Cogs::TextureFormat::R16G16B16A16_FLOAT: return CogsBin3::Format::R16G16B16A16_FLOAT; break;
    case Cogs::TextureFormat::R32_FLOAT:          return CogsBin3::Format::R32_FLOAT; break;
    case Cogs::TextureFormat::R32G32_FLOAT:       return CogsBin3::Format::R32G32_FLOAT; break;
    case Cogs::TextureFormat::R32G32B32_FLOAT:    return CogsBin3::Format::R32G32B32_FLOAT; break;
    case Cogs::TextureFormat::R32G32B32A32_FLOAT: return CogsBin3::Format::R32G32B32A32_FLOAT; break;
    case Cogs::TextureFormat::D16_UNORM:          return CogsBin3::Format::D16_UNORM; break;
    case Cogs::TextureFormat::D24_UNORM:          return CogsBin3::Format::D24_UNORM; break;
    case Cogs::TextureFormat::D24S8_UNORM:        return CogsBin3::Format::D24S8_UNORM; break;
    case Cogs::TextureFormat::D32_FLOAT:          return CogsBin3::Format::D32_FLOAT; break;
    case Cogs::TextureFormat::R32_TYPELESS:       return CogsBin3::Format::R32_TYPELESS; break;
    case Cogs::TextureFormat::R16_TYPELESS:       return CogsBin3::Format::R16_TYPELESS; break;
    case Cogs::TextureFormat::R8T:                return CogsBin3::Format::R8T; break;
    case Cogs::TextureFormat::R8G8T:              return CogsBin3::Format::R8G8T; break;
    case Cogs::TextureFormat::R8G8B8T:            return CogsBin3::Format::R8G8B8T; break;
    case Cogs::TextureFormat::R8G8B8A8T:          return CogsBin3::Format::R8G8B8A8T; break;
    case Cogs::TextureFormat::B8G8R8:             return CogsBin3::Format::B8G8R8; break;
    case Cogs::TextureFormat::B8G8R8A8:           return CogsBin3::Format::B8G8R8A8; break;
    case Cogs::TextureFormat::A8_UNORM:           return CogsBin3::Format::A8_UNORM; break;
    case Cogs::TextureFormat::BC1_TYPELESS:       return CogsBin3::Format::BC1_TYPELESS; break;
    case Cogs::TextureFormat::BC1_UNORM:          return CogsBin3::Format::BC1_UNORM; break;
    case Cogs::TextureFormat::BC1_UNORM_SRGB:     return CogsBin3::Format::BC1_UNORM_SRGB; break;
    case Cogs::TextureFormat::BC2_TYPELESS:       return CogsBin3::Format::BC2_TYPELESS; break;
    case Cogs::TextureFormat::BC2_UNORM:          return CogsBin3::Format::BC2_UNORM; break;
    case Cogs::TextureFormat::BC2_UNORM_SRGB:     return CogsBin3::Format::BC2_UNORM_SRGB; break;
    case Cogs::TextureFormat::BC3_TYPELESS:       return CogsBin3::Format::BC3_TYPELESS; break;
    case Cogs::TextureFormat::BC3_UNORM:          return CogsBin3::Format::BC3_UNORM; break;
    case Cogs::TextureFormat::BC3_UNORM_SRGB:     return CogsBin3::Format::BC3_UNORM_SRGB; break;
    case Cogs::TextureFormat::BC4_TYPELESS:       return CogsBin3::Format::BC4_TYPELESS; break;
    case Cogs::TextureFormat::BC4_UNORM:          return CogsBin3::Format::BC4_UNORM; break;
    case Cogs::TextureFormat::BC4_SNORM:          return CogsBin3::Format::BC4_SNORM; break;
    case Cogs::TextureFormat::BC5_TYPELESS:       return CogsBin3::Format::BC5_TYPELESS; break;
    case Cogs::TextureFormat::BC5_UNORM:          return CogsBin3::Format::BC5_UNORM; break;
    case Cogs::TextureFormat::BC5_SNORM:          return CogsBin3::Format::BC5_SNORM; break;
    case Cogs::TextureFormat::R8G8B8A8_UNORM_SRGB:  return CogsBin3::Format::R8G8B8A8_UNORM_SRGB; break;
    default:
      assert(false && "Illegal format");
      break;
    }
    return CogsBin3::Format::Unknown;
  }
 
  WSection& getSection(WriteContext& wctx, CogsBin3::SectionType type, uint16_t index, bool create=true)
  {
    if (wctx.sections.size() <= index) wctx.sections.resize((size_t)index + 1);
    if (!wctx.sections[index]) {
      assert(create && "Trying to retrieve non-existing section");
      wctx.sections[index] = std::make_unique<WSection>(WSection{ type, index, 0, 0, {}, {} });
    }
    auto & section = *wctx.sections[index].get();
    section.type = section.type | type;
 
    return section;
  }
 
  uint32_t addMetaSubsection(WriteContext& /*wctx*/, WSection& section, CogsBin3::SubSectionType type, size_t size)
  {
    assert(section.contents.empty() && "Cannot add metasubsections after data payload has been added.");
    assert(size < std::numeric_limits<uint32_t>::max());
 
    auto index = nextIndex(section.subSections);
    section.subSections.push_back(WSubSection{ ~0u, uint32_t(size), type });
    return index;
  }
 
  uint32_t newNode(WriteContext& wctx)
  {
    uint32_t index = nextIndex(wctx.nodes);
    auto & node = wctx.nodes.emplace_back();
    node.parent = ~0u;
    node.name = ~0u;
    node.mesh = ~0u;
    node.materialInstance = ~0u;
    node.transform = ~0u;
    node.boundingBox = ~0u;
    node.primitiveType = CogsBin3::PrimitiveType::TriangleList;
    node.vertexFirst = 0;
    node.vertexCount = 0;
    return index;
  }
 
  uint32_t recordTransform(WriteContext& wctx, const glm::mat4& M)
  {
    glm::mat4 I;
    if (std::memcmp(glm::value_ptr(I), glm::value_ptr(M), sizeof(M)) == 0) {
      //LOG_DEBUG(logger, "Identity matrix.");
      return ~0u;
    }
 
    // assume affine transform matrix
    const auto * m = glm::value_ptr(M);
    CogsBin3::Transform T{
      m[0], m[1], m[2],
      m[4], m[5], m[6],
      m[8], m[9], m[10],
      m[12], m[13], m[14]
    };
    size_t hashValue = T.hash();
 
    if (auto it = wctx.transformByHash.find(hashValue); it != wctx.transformByHash.end()) {
      if (std::memcmp(&wctx.transforms[it->second], &T, sizeof(T)) == 0) {
        //LOG_DEBUG(logger, "Found duplicate transform.");
        return it->second;
      }
    }
 
    auto index = nextIndex(wctx.transforms);
    wctx.transforms.emplace_back(T);
    wctx.transformByHash[hashValue] = index;
    return index;
  }
 
  uint32_t recordBoundingBox(WriteContext& wctx, const Cogs::Geometry::BoundingBox& bbox)
  {
    if (isEmpty(bbox)) {
      //LOG_DEBUG(logger, "Empty bbox.\n");
      return ~0u;
    }
 
    // FIXME (chrisdy): Not really sure if this is worthwhile
    size_t hashValue = bbox.hash();
    if (auto it = wctx.boundingBoxByHash.find(hashValue); it != wctx.boundingBoxByHash.end()) {
      if (std::memcmp(&wctx.boundingBoxes[it->second], &bbox, sizeof(bbox)) == 0) {
        LOG_DEBUG(logger, "Found duplicate bounding box.");
        return it->second;
      }
    }
 
    auto index = nextIndex(wctx.boundingBoxes);
    wctx.boundingBoxes.emplace_back(bbox);
    wctx.transformByHash[hashValue] = index;
    return index;
  }
 
  size_t getMaterialInstanceHash(MaterialInstance * material)
  {
    size_t hashValue = material->getName().hash();
 
    if (material->material->getName() == "DefaultMaterial") {
      hashValue = Cogs::hash(material->getVec4Property(DefaultMaterial::DiffuseColor), hashValue);
      hashValue = Cogs::hash(material->getVec3Property(DefaultMaterial::SpecularColor), hashValue);
      hashValue = Cogs::hash(material->getVec3Property(DefaultMaterial::EmissiveColor), hashValue);
      hashValue = Cogs::hash(material->getFloatProperty(DefaultMaterial::SpecularPower), hashValue);
      hashValue = Cogs::hash(reinterpret_cast<intptr_t>(material->getTextureProperty(DefaultMaterial::DiffuseMap).texture.handle.get()), hashValue);
    }
    else {
      hashValue = Cogs::hash(reinterpret_cast<intptr_t>(material));
    }
    return hashValue;
  }
 
  uint32_t recordString(WriteContext& wctx, Cogs::StringView string)
  {
    if (string.empty()) return ~0u;
 
    auto hash = string.hash();
    if (auto it = wctx.stringByHash.find(hash); it != wctx.stringByHash.end()) {
      auto & str = wctx.strings[it->second];
      if (string == Cogs::StringView((const char*)(wctx.stringData.data() + str.offset), str.length)) {
        return it->second;
      }
    }
 
    auto offset = wctx.stringData.size();
    assert(offset < std::numeric_limits<uint32_t>::max());
 
    auto length = string.length();
    assert(length < std::numeric_limits<uint32_t>::max());
 
    auto index = nextIndex(wctx.strings);
    wctx.strings.emplace_back(CogsBin3::String{ uint32_t(offset), uint32_t(length) });
 
    wctx.stringData.resize(offset + length);
    std::memcpy(wctx.stringData.data() + offset, string.begin(), length);
 
    wctx.stringByHash[hash] = index;
    return index;
  }
 
  uint32_t recordAttribute(WriteContext& wctx, const Cogs::VertexElement& element)
  {
    assert(element.offset <= std::numeric_limits<uint16_t>::max());
 
    auto index = nextIndex(wctx.vertexAttributes);
 
    wctx.vertexAttributes.emplace_back(CogsBin3::VertexAttribute{});
    auto & attribute = wctx.vertexAttributes.back();
 
    attribute.offset = uint16_t(element.offset);
    attribute.format = (CogsBin3::Format)element.format;
 
    switch (element.semantic) {
    case Cogs::ElementSemantic::Position:           attribute.semantic = CogsBin3::Semantic::Position; break;
    case Cogs::ElementSemantic::Normal:             attribute.semantic = CogsBin3::Semantic::Normal; break;
    case Cogs::ElementSemantic::Color:              attribute.semantic = CogsBin3::Semantic::Color; break;
    case Cogs::ElementSemantic::TextureCoordinate:  attribute.semantic = CogsBin3::Semantic::TexCoord; break;
    case Cogs::ElementSemantic::Tangent:            attribute.semantic = CogsBin3::Semantic::Tangent; break;
    case Cogs::ElementSemantic::InstanceVector:     attribute.semantic = CogsBin3::Semantic::InstanceVector; break;
    case Cogs::ElementSemantic::InstanceMatrix:     attribute.semantic = CogsBin3::Semantic::InstanceMatrix; break;
    default:
      assert(false && "Unknown element.format");
    }
    assert(element.semanticIndex <= std::numeric_limits<uint8_t>::max());
    attribute.semanticIndex = uint8_t(element.semanticIndex);
 
    if (element.inputType == Cogs::InputType::VertexData) {
      attribute.instanceStepRate = 0;
    }
    else {
      attribute.instanceStepRate = uint16_t(std::min(1 + (uint32_t)element.instanceStep, unsigned(std::numeric_limits<uint16_t>::max())));
    }
    return index;
  }
 
  bool match(const Cogs::VertexFormat& a, const Cogs::VertexFormat& b)
  {
    if (a.elements.size() != b.elements.size()) return false;
    for (size_t i = 0; i < a.elements.size(); i++) {
      const auto & ae = a.elements[i];
      const auto & be = b.elements[i];
 
      if ((ae.offset != be.offset) ||
          (ae.format != be.format) ||
          (ae.semantic != be.semantic) ||
          (ae.semanticIndex != be.semanticIndex) ||
          (ae.inputType != be.inputType) ||
          (ae.instanceStep != be.instanceStep))
      {
        return false;
      }
    }
    return true;
  }
 
  uint32_t recordBuffer(WriteContext& wctx, uint64_t size, CogsBin3::BufferContentFlags flags, uint32_t alignment, uint16_t sectionIx)
  {
    assert(alignment);
    assert(size);
    assert(alignment <= CogsBin3::CogsSectionAlignment);
 
    const auto lowerMask = uint64_t(alignment - 1);
 
    auto & section = getSection(wctx, CogsBin3::SectionType::DATA, sectionIx);
    section.dataSize = (section.dataSize + lowerMask)&(~lowerMask);
    section.dataSize += size;
 
    auto index = nextIndex(wctx.buffers);
    wctx.buffers.emplace_back(CogsBin3::Buffer{});
    wctx.bufferContexts.emplace_back();
 
    auto & buffer = wctx.buffers.back();
    buffer.sectionOffset = sectionIx;
    //TODO: Review buffer size usage.
    buffer.size = (uint32_t)size;
    buffer.flags = flags;
 
    wctx.bufferContexts[index].contents.resize(size, false);
    wctx.bufferContexts[index].alignment = alignment;
 
    return index;
  }
 
  uint8_t* getBufferPointer(WriteContext& wctx, uint32_t bufferIx, uint32_t offset, uint64_t size)
  {
    assert(bufferIx < wctx.buffers.size());
    auto & bufferCtx = wctx.bufferContexts[bufferIx];
    assert(offset + size <= bufferCtx.contents.size());
    return (uint8_t*)bufferCtx.contents.data() + offset;
  }
 
  uint32_t recordBufferResource(WriteContext& wctx, BufferResource* srcBuffer, uint16_t sectionIx)
  {
    if (srcBuffer == nullptr || srcBuffer->empty()) {
      return ~0u;
    }
 
    if (auto it = wctx.bufferByPointer.find(srcBuffer); it != wctx.bufferByPointer.end()) {
      return it->second;
    }
 
    CogsBin3::BufferContentFlags flags = CogsBin3::BufferContentFlags::None;
    if (srcBuffer->isVertexBuffer()) flags |= CogsBin3::BufferContentFlags::VertexData;
    if (srcBuffer->isIndexBuffer()) flags |= CogsBin3::BufferContentFlags::IndexData;
 
    constexpr uint32_t bufferStride = 16;
    auto alignment = std::min(uint32_t(CogsBin3::CogsSectionAlignment), uint32_t(bufferStride)); // No point in aligning beyond a cache line.
    uint32_t index = recordBuffer(wctx, srcBuffer->size(), flags, alignment, sectionIx);
    std::memcpy(getBufferPointer(wctx, index, 0, srcBuffer->size()), srcBuffer->data(), srcBuffer->size());
 
    wctx.bufferByPointer[srcBuffer] = index;
 
    return index;
  }
 
  void recordVertexFormat(WriteContext& wctx, CogsBin3::VertexStream& stream, const DataStream& srcStream)
  {
    const auto & srcFormat = *Cogs::VertexFormats::getVertexFormat(srcStream.format);
    assert(srcFormat.size <= std::numeric_limits<uint16_t>::max());
    stream.stride = uint16_t(srcFormat.size);
 
    assert(srcFormat.elements.size() < std::numeric_limits<uint32_t>::max());
    stream.attributeCount = uint32_t(srcFormat.elements.size());
 
    auto hash = Cogs::getHash(srcFormat);
    assert(hash);
    if (auto it = wctx.vertexFormatByHash.find(hash); it != wctx.vertexFormatByHash.end() && match(*it->second.format, srcFormat)) {
      stream.firstAttribute = it->second.index;
    }
    else {
      stream.firstAttribute = recordAttribute(wctx, srcFormat.elements[0]);
      for (size_t i = 1; i < srcFormat.elements.size(); i++) {
        auto ix = recordAttribute(wctx, srcFormat.elements[i]);
        assert(stream.firstAttribute + i == ix);
      }
      wctx.vertexFormatByHash[hash] = WVertexFormatRec{ &srcFormat, stream.firstAttribute };
    }
  }
 
  uint32_t recordVertexStream(WriteContext& wctx, const DataStream& srcStream, uint16_t sectionIx)
  {
    assert(srcStream.size() <= std::numeric_limits<uint32_t>::max());
 
    auto index = nextIndex(wctx.vertexStreams);
    auto & stream = wctx.vertexStreams.emplace_back(CogsBin3::VertexStream{ 0, 0, 0, 0, 0, 0, 0, 0 });
    stream.firstAttribute = ~0u;
    stream.vertexDataType = srcStream.type;
    stream.encoding = 0;
 
    if (srcStream.format) {
      recordVertexFormat(wctx, stream, srcStream);
    } else {
      stream.stride = (uint16_t)srcStream.stride;
    }
 
    assert((size_t)stream.count * (size_t)stream.stride <= srcStream.size());
 
    stream.count = srcStream.numElements;
    stream.buffer = recordBufferResource(wctx, srcStream.buffer.resolve(), sectionIx);
    stream.offset = srcStream.offset;
 
    return index;
  }
 
  uint32_t recordMesh(WriteContext& wctx, Mesh* srcMesh, uint16_t section)
  {
    if (srcMesh == nullptr || srcMesh->streams.empty()) {
      return ~0u;
    }
 
    if (auto it = wctx.meshByPointer.find(srcMesh); it != wctx.meshByPointer.end()) {
      LOG_DEBUG(logger, "Duplicate mesh, recycling.");
      return it->second;
    }
 
    uint32_t firstStream = 0;
    uint32_t streamCount = 0;
    for (size_t i = 0; i < srcMesh->streams.size(); i++) {
      if (srcMesh->streams[i].size() != 0) {
        uint32_t streamIx = recordVertexStream(wctx, srcMesh->streams[i], section);
        if (streamCount == 0) {
          firstStream = streamIx;
        }
        assert(firstStream + streamCount == streamIx);
        streamCount++;
      }
    }
 
    auto index = nextIndex(wctx.meshes);
    auto & mesh = wctx.meshes.emplace_back();
    mesh.name = recordString(wctx, srcMesh->getName());
    mesh.firstStream = firstStream;
    mesh.streamCount = (uint8_t)streamCount;
    mesh.boundingBox = recordBoundingBox(wctx, srcMesh->boundingBox);
    mesh.flags =
      (srcMesh->isCCW() ? CogsBin3::MeshFlags::None : CogsBin3::MeshFlags::Clockwise) |
      (srcMesh->isMeshFlagSet(MeshFlags::Skinned) ? CogsBin3::MeshFlags::Skinned : CogsBin3::MeshFlags::None);
 
    mesh.primitiveType = translatePrimitiveType(wctx, srcMesh->primitiveType);
 
    wctx.meshByPointer[srcMesh] = index;
 
    return index;
  }
 
  template<typename T>
  uint32_t recordProperty(WriteContext& wctx, const Cogs::StringView& key, CogsBin3::PropertyValueType valueType, const T & value)
  {
    auto keyIx = recordString(wctx, key);
 
    // TODO (chrisdy): Check if this caching is worthwhile in practice.
    size_t hash = Cogs::hashSequence(keyIx, valueType, value);
    if (auto it = wctx.propByHash.find(hash); it != wctx.propByHash.end()) {
      auto & p = wctx.properties[it->second];
      if (p.keyType == CogsBin3::PropertyKeyType::String &&
          p.key == keyIx &&
          p.valueType == valueType)
      {
        if constexpr (sizeof(T) <= sizeof(uint32_t)) {
          if (*(T*)(&p.value) == value) {
            //LOG_DEBUG(logger, "Found duplicate property (small), recycling.");
            return it->second;
          }
        }
        else {
          if (*(T*)(wctx.propertyData.data() + p.value) == value) {
            //LOG_DEBUG(logger, "Found duplicate property (large), recycling.");
            return it->second;
          }
        }
      }
    }
 
    auto index = nextIndex(wctx.properties);
    wctx.properties.emplace_back(CogsBin3::Property{ CogsBin3::PropertyKeyType::String, valueType, keyIx, ~0u });
    auto & prop = wctx.properties.back();
 
    if constexpr (sizeof(T) <= sizeof(uint32_t)) {  // values that fit inside the index are stored inline
      *(T*)(&prop.value) = value;
    }
    else {
      constexpr auto align = alignof(T);
      static_assert(align != 0 && (align & (align - 1)) == 0 && "alignment is not a power of two");
      const auto mask = align - 1;
      auto offset = (wctx.propertyData.size() + mask) & ~mask;  // pad to natural alignment
      assert(offset < std::numeric_limits<uint32_t>::max());
      prop.value = uint32_t(offset);
      wctx.propertyData.resize(wctx.propertyData.size() + sizeof(value));
      *(T*)(wctx.propertyData.data() + offset) = value;
    }
    return index;
  }
 
  uint32_t recordStringBasedProperty(WriteContext& wctx, const Cogs::StringView& key, CogsBin3::PropertyValueType valueType, const Cogs::StringView& value)
  {
    auto index = nextIndex(wctx.properties);
    wctx.properties.emplace_back();
    auto & prop = wctx.properties.back();
    prop.keyType = CogsBin3::PropertyKeyType::String;
    prop.key = recordString(wctx, key);
    prop.valueType = valueType;
    prop.value = recordString(wctx, value);
    return index;
  }
 
  uint32_t recordTexture(WriteContext& wctx, const Texture* srcTex, uint16_t sectionIx)
  {
    assert(srcTex);
    assert(srcTex->storage.data.size() != 0);
 
    if (auto it = wctx.knownTexturesByPointer.find(srcTex); it != wctx.knownTexturesByPointer.end()) {
      return it->second;
    }
    auto texIx = nextIndex(wctx.textures);
    wctx.textures.emplace_back(CogsBin3::Texture{});
    wctx.knownTexturesByPointer[srcTex] = texIx;
    auto & dstTex = wctx.textures.back();
 
    // Store image data
    assert(srcTex->storage.data.size() <= std::numeric_limits<uint32_t>::max());
    const auto size = uint32_t(srcTex->storage.data.size());
    dstTex.buffer = recordBuffer(wctx, size, CogsBin3::BufferContentFlags::TextureData, 4, sectionIx);
    std::memcpy(getBufferPointer(wctx, dstTex.buffer, 0, size), srcTex->storage.data.data(), size);
 
    dstTex.offset = 0;
    dstTex.size = size;
    dstTex.encoding = CogsBin3::TextureEncoding::None;
    dstTex.name = recordString(wctx, srcTex->getName());
    dstTex.width = srcTex->description.width;
    dstTex.height = srcTex->description.height;
    dstTex.depth = srcTex->description.depth;
    dstTex.format = translateFormat(srcTex->description.format);
    dstTex.flags = CogsBin3::TextureFlags::None;
 
    return texIx;
  }
 
  uint32_t recordMaterialInstance(WriteContext& wctx, MaterialInstance* srcMatInst, uint16_t sectionIx)
  {
    if (srcMatInst == nullptr) return ~0u;
 
    if (auto it = wctx.knownMaterialInstancesByPointer.find(srcMatInst); it != wctx.knownMaterialInstancesByPointer.end()) {
      return it->second;
    }
 
    auto hash = getMaterialInstanceHash(srcMatInst);
    if (auto it = wctx.knownMaterialInstancesByHash.find(hash); it != wctx.knownMaterialInstancesByHash.end()) {
      return it->second;
    }
 
    auto index = nextIndex(wctx.materialInstances);
    wctx.materialInstances.emplace_back();
    auto & dstMatInst = wctx.materialInstances.back();
 
    wctx.knownMaterialInstancesByPointer[srcMatInst] = index;
    wctx.knownMaterialInstancesByHash[hash] = index;
 
    dstMatInst.material = recordString(wctx, srcMatInst->material->getName());
    dstMatInst.permutation = recordString(wctx, srcMatInst->getPermutation());
    dstMatInst.propertyFirst = nextIndex(wctx.properties);
    dstMatInst.propertyCount = 0;
 
    for (auto & prop : srcMatInst->material->constantBuffers.variables) {
      switch (prop.type) {
      case MaterialDataType::Float:
        if (auto val = srcMatInst->getFloatProperty(prop.key); val != prop.defaultFloat()) {
          recordProperty(wctx, prop.name, CogsBin3::PropertyValueType::Float, val);
          dstMatInst.propertyCount++;
        }
        break;
      case MaterialDataType::Float2:
        if (auto val = srcMatInst->getVec2Property(prop.key); val != prop.defaultVec2()) {
          recordProperty(wctx, prop.name, CogsBin3::PropertyValueType::Float2, val);
          dstMatInst.propertyCount++;
        }
        break;
      case MaterialDataType::Float3:
        if (auto val = srcMatInst->getVec3Property(prop.key); val != prop.defaultVec3()) {
          recordProperty(wctx, prop.name, CogsBin3::PropertyValueType::Float3, val);
          dstMatInst.propertyCount++;
        }
        break;
      case MaterialDataType::Float4:
        if (auto val = srcMatInst->getVec4Property(prop.key); val != prop.defaultVec4()) {
          recordProperty(wctx, prop.name, CogsBin3::PropertyValueType::Float4, val);
          dstMatInst.propertyCount++;
        }
        break;
      case MaterialDataType::Bool:
        if (auto val = srcMatInst->getBoolProperty(prop.key); val != prop.defaultBool()) {
          recordProperty(wctx, prop.name, CogsBin3::PropertyValueType::Bool, (uint32_t)val);
          dstMatInst.propertyCount++;
        }
        break;
      case MaterialDataType::UInt:
        if (auto val = srcMatInst->getProperty<uint32_t>(prop.key); val != prop.defaultUInt()) {
          recordProperty(wctx, prop.name, CogsBin3::PropertyValueType::UInt, (uint32_t)val);
          dstMatInst.propertyCount++;
        }
        break;
      default:
        LOG_WARNING(logger, "Skipped serialization of unsupported material property %s of type %u.", prop.name.c_str(), unsigned(prop.type));
        break;
      }
    }
 
 
    if ((wctx.flags & WriteModelFlags::EMBED_TEXTURES) != 0) {
      for (auto & prop : srcMatInst->material->textureProperties) {
        auto value = srcMatInst->getTextureProperty(prop.key);
        if (value.texture.handle && value.texture.handle != prop.texture.handle) {  // different texture on instance than on material.
          auto * tex = value.texture.handle.resolve();
          if (tex->storage.data.size() == 0) {
            LOG_WARNING(logger, "Empty texture, skipping.");
            continue;
          }
          uint32_t texIx = recordTexture(wctx, tex, sectionIx);
          recordProperty(wctx, prop.name, CogsBin3::PropertyValueType::EmbeddedTexture, texIx);
          dstMatInst.propertyCount++;
        }
      }
    }
 
    else {
      for (uint32_t texI = 0; texI < srcMatInst->material->textureProperties.size(); texI++) {
        const TextureProperty& prop = srcMatInst->material->textureProperties[texI];
        const TextureValue& value = srcMatInst->getTextureProperty(prop.key);
        if (value.texture.handle && value.texture.handle != prop.texture.handle) {
          std::string source = value.texture.handle->getSource().to_string();
          const std::string dir = Cogs::IO::parentPath(wctx.fileName);
          if (source.empty()) {
            // If the source is empty, try to write the texture data to a png and use that as source.
            const Texture* tex = value.texture.handle.resolve();
            if (tex->storage.data.size() == 0) {
              LOG_WARNING(logger, "Skipping texture without source or data.");
              continue;
            }
            const std::string textureName = Cogs::IO::stem(wctx.fileName) + "_texture_" + std::to_string(index) + std::to_string(texI) + ".png";
            source = Cogs::IO::combine(dir, textureName);
            const Cogs::FormatInfo* formatInfo = getFormatInfo(tex->description.format);
            if (!stbi_write_png(source.c_str(), tex->description.width, tex->description.height, formatInfo->elements, tex->storage.data.data(), 0)) {
              LOG_ERROR(logger, "Failed to write texture %s.", source.c_str());
              return ~0u;
            }
          }
          recordStringBasedProperty(wctx, prop.name, CogsBin3::PropertyValueType::String, Cogs::IO::relativePath(source, dir));
          dstMatInst.propertyCount++;
        }
      }
    }
 
    const ShaderVariants& variants = srcMatInst->material->definition.variants;
    for (const ShaderVariantSelector& selector : srcMatInst->variantSelectors) {
      const ShaderVariantDefinition& variant = variants[selector.index];
      if (variant.isShared) continue; // Do not store shared variants.
      if (selector.value != variant.defaultValue) {
        if (variant.type == ShaderVariantType::Enum) {
          recordStringBasedProperty(wctx, variant.name, CogsBin3::PropertyValueType::Variant, variant.values[selector.value].key);
          dstMatInst.propertyCount++;
        }
        else {
          recordStringBasedProperty(wctx, variant.name, CogsBin3::PropertyValueType::Variant, selector.value ? "true" : "false");
          dstMatInst.propertyCount++;
        }
      }
    }
 
    assert(dstMatInst.propertyFirst + dstMatInst.propertyCount == nextIndex(wctx.properties));
    return index;
  }
 
  uint32_t recordSkeleton(WriteContext& wctx, const Skeleton& srcSkeleton)
  {
    if (srcSkeleton.bones.empty()) return ~0u;
 
    auto index = nextIndex(wctx.skeletons);
    wctx.skeletons.emplace_back(CogsBin3::Skeleton{});
    auto & dstSkeleton = wctx.skeletons.back();
    dstSkeleton.bindPose = srcSkeleton.bindPose;
    dstSkeleton.firstBone = nextIndex(wctx.bones);
    dstSkeleton.boneCount = uint32_t(srcSkeleton.bones.size());
    for (const auto & srcBone : srcSkeleton.bones) {
      wctx.bones.emplace_back(CogsBin3::Bone{});
      auto & dstBone = wctx.bones.back();
      dstBone.inverseBindPose = srcBone.inverseBindPose;
      dstBone.relative = srcBone.relative;
      dstBone.rot = srcBone.rot;
      dstBone.pos = srcBone.pos;
      dstBone.scale = srcBone.scale;
      dstBone.name = recordString(wctx, srcBone.name);
      dstBone.parentBone = uint16_t(srcBone.parentBone);
      dstBone.flags =
        (srcBone.hasOffset ? CogsBin3::BoneFlags::HasOffset : CogsBin3::BoneFlags::None) |
        (srcBone.used      ? CogsBin3::BoneFlags::Used      : CogsBin3::BoneFlags::None) |
        (srcBone.animated  ? CogsBin3::BoneFlags::Animated  : CogsBin3::BoneFlags::None);
    }
    return index;
  }
 
  uint32_t recordPart(WriteContext& wctx, const Model& model, const ModelPart& part, uint16_t section)
  {
    auto nodeIndex = newNode(wctx);
    auto & node = wctx.nodes[nodeIndex];
 
    node.parent = part.parentIndex;
    if (part.nameIndex != -1) {
      node.name = recordString(wctx, model.getPartName(part));
    }
    if (part.transformIndex != -1) {
      node.transform = recordTransform(wctx, model.getPartTransform(part));
    }
 
    if (part.meshIndex != -1) {
      auto * mesh = model.meshes[part.meshIndex].resolve();
      node.mesh = recordMesh(wctx, mesh, 0);
      node.boundingBox = recordBoundingBox(wctx, mesh->boundingBox);
      node.primitiveType = translatePrimitiveType(wctx, mesh->primitiveType);      // FIXME: currently just use the primitive type of mesh since part has primtitive type.
      node.vertexFirst = part.startIndex;
      node.vertexCount = part.vertexCount;
      if (part.materialIndex != -1) {
        node.materialInstance = recordMaterialInstance(wctx, model.materials[part.materialIndex].resolve(), section);
      }
    }
 
    return nodeIndex;
  }
 
  void recordAnimTrack(WriteContext& wctx, const AnimationTrack& srcTrack, uint16_t sectionIx)
  {
    wctx.animTracks.emplace_back(CogsBin3::AnimTrack{});
    auto & dstTrack = wctx.animTracks.back();
 
    const auto translationCount = uint32_t(srcTrack.translations.size());
    const auto rotationCount = uint32_t(srcTrack.rotations.size());
    const auto scaleCount = uint32_t(srcTrack.scales.size());
 
    dstTrack.boneIndex = uint32_t(srcTrack.boneIndex);
    dstTrack.buffer = recordBuffer(wctx,
                                   sizeof(float)*(4 * (size_t)translationCount + 5 * (size_t)rotationCount + 4 * (size_t)scaleCount),
                                   CogsBin3::BufferContentFlags::AnimationData, 4, sectionIx);
 
    auto * base = (float*)wctx.bufferContexts[dstTrack.buffer].contents.data();
    auto * ptr = base;
 
    dstTrack.translationOffset = uint32_t((uint8_t*)ptr - (uint8_t*)base);
    for(auto & translation : srcTrack.translations) {
      *ptr++ = translation.t;
      *ptr++ = translation.value[0];
      *ptr++ = translation.value[1];
      *ptr++ = translation.value[2];
    }
    dstTrack.translationCount = translationCount;
    assert(uint32_t((uint8_t*)ptr - (uint8_t*)base) - dstTrack.translationOffset == sizeof(float) * 4 * translationCount);
 
    dstTrack.rotationOffset = uint32_t((uint8_t*)ptr - (uint8_t*)base);
    for (auto & rotation : srcTrack.rotations) {
      *ptr++ = rotation.t;
      *ptr++ = rotation.value[0];
      *ptr++ = rotation.value[1];
      *ptr++ = rotation.value[2];
      *ptr++ = rotation.value[3];
    }
    dstTrack.rotationCount = rotationCount;
    assert(uint32_t((uint8_t*)ptr - (uint8_t*)base) - dstTrack.rotationOffset == sizeof(float) * 5 * rotationCount);
 
    dstTrack.scaleOffset = uint32_t((uint8_t*)ptr - (uint8_t*)base);
    for (auto & scale : srcTrack.scales) {
      *ptr++ = scale.t;
      *ptr++ = scale.value[0];
      *ptr++ = scale.value[1];
      *ptr++ = scale.value[2];
    }
    dstTrack.scaleCount = scaleCount;
    assert(uint32_t((uint8_t*)ptr - (uint8_t*)base) - dstTrack.scaleOffset == sizeof(float) * 4 * scaleCount);
    assert(uint32_t((uint8_t*)ptr - (uint8_t*)base) == sizeof(float) * (4 * translationCount + 5 * rotationCount + 4 * scaleCount));
  }
 
  void recordAnimClip(WriteContext& wctx, const AnimationClip& srcClip, uint16_t sectionIx)
  {
    wctx.animClips.emplace_back(CogsBin3::AnimClip{});
    auto & dstClip = wctx.animClips.back();
    dstClip.name = recordString(wctx, srcClip.name);
    dstClip.duration = srcClip.duration;
    dstClip.resolution = srcClip.resolution;
    if (!srcClip.tracks.empty()) {
      dstClip.trackFirst = nextIndex(wctx.animTracks);
      dstClip.trackCount = uint32_t(srcClip.tracks.size());
      for (auto const & track : srcClip.tracks) recordAnimTrack(wctx, track, sectionIx);
      assert(dstClip.trackFirst + dstClip.trackCount == wctx.animTracks.size());
    }
    else {
      dstClip.trackFirst = ~0u;
      dstClip.trackCount = 0;
    }
  }
 
  void recordModel(WriteContext& wctx, const Model * srcModel, WriteModelFlags /*flags*/)
  {
    if (srcModel->parts.empty()) return;    // Now we know that it is atleast one part.
 
    uint16_t section = 0;
 
    wctx.models.emplace_back(CogsBin3::Model{});
    auto & dstModel = wctx.models.back();
    dstModel.skeleton = (uint32_t)-1;
    dstModel.animClipFirst = (uint32_t)-1;
    dstModel.animClipCount = 0;
    if (auto * animation = srcModel->animation.resolve(); animation) {
      dstModel.skeleton = recordSkeleton(wctx, animation->skeleton);
      if (!animation->clips.empty()) {
        dstModel.animClipFirst = nextIndex(wctx.animClips);
        dstModel.animClipCount = uint32_t(animation->clips.size());
        for (const auto & clip : animation->clips) recordAnimClip(wctx, clip, section);
        assert(dstModel.animClipFirst + dstModel.animClipCount == wctx.animClips.size());
      }
    }
 
    dstModel.firstNode = recordPart(wctx, *srcModel, srcModel->parts[0], section);
    for (size_t i = 1; i < srcModel->parts.size(); i++) {
      auto ix = recordPart(wctx, *srcModel, srcModel->parts[i], 0);
      assert(dstModel.firstNode + i == ix);
    }
    dstModel.nodeCount = uint32_t(srcModel->parts.size());
  }
 
  uint32_t recordEntity(Context* context, WriteContext& wctx, uint32_t parent, Cogs::ComponentModel::Entity* entity, uint16_t section)
  {
    auto nodeIndex = newNode(wctx);
    auto & node = wctx.nodes[nodeIndex];
 
    node.parent = parent;
    node.name = recordString(wctx, entity->getName());
 
    if (const auto * trComp = entity->getComponent<TransformComponent>(); trComp) {
      node.transform = recordTransform(wctx, context->transformSystem->getLocalTransform(trComp));
    }
 
    if (auto meshComponent = entity->getComponent<MeshComponent>();  meshComponent && meshComponent->meshHandle) {
      auto mesh = meshComponent->meshHandle;
      if (mesh && mesh->streams.size()) {
        auto renderComponent = entity->getComponent<MeshRenderComponent>();
        if (renderComponent) {
          node.mesh = recordMesh(wctx, mesh.resolve(), section);
          if (renderComponent->primitiveType != (Cogs::PrimitiveType::EPrimitiveType)-1) {
            node.primitiveType = translatePrimitiveType(wctx, renderComponent->primitiveType);
          } else {
            node.primitiveType = CogsBin3::PrimitiveType::Unknown;
          }
          node.vertexFirst = renderComponent->startIndex;
          node.vertexCount = renderComponent->vertexCount;
          node.boundingBox =  recordBoundingBox(wctx, context->renderSystem->getLocalBounds(renderComponent));
          if (renderComponent->material) {
            node.materialInstance = recordMaterialInstance(wctx, renderComponent->material.resolve(), section);
          }
        }
        else {
          LOG_ERROR(logger, "MeshComponent must be accompanied by a MeshRenderComponent for export.");
        }
      }
    }
 
    if (auto * sceneComponent = entity->getComponent<SceneComponent>(); sceneComponent) {
      for (auto & child : sceneComponent->children) {
        recordEntity(context, wctx, nodeIndex, child.get(), section);
      }
    }
 
    if (auto * animComp = entity->getComponent<AnimationComponent>(); animComp) {
 
      auto * anim = animComp->animation.resolve();
      if (animComp->master) {
        auto * master = animComp->master.resolveComponent<AnimationComponent>();
        anim = master->animation.resolve();
      }
      if (wctx.currentAnimation == nullptr) {
        wctx.currentAnimation = anim;
      }
      else if (wctx.currentAnimation != anim) {
        LOG_ERROR(logger, "Multiple animations within a single model's hierarchy");
      }
    }
 
    return nodeIndex;
  }
 
  void layoutSections(WriteContext& wctx)
  {
    for (size_t i = 0; i < wctx.sections.size(); i++) {
      auto & section = *wctx.sections[i].get();
 
      assert(section.contents.empty() && "Sections already laid out");
 
      // lay out subsections at start
      section.writePos = sizeof(CogsBin3::SubSectionInfo)*section.subSections.size();
      for (auto & subsection : section.subSections) {
        section.writePos = align(section.writePos);
        assert(section.writePos < std::numeric_limits<uint32_t>::max());
        subsection.offset = section.writePos;
        section.writePos += subsection.size;
      }
      section.writePos = align(section.writePos);
 
      // Add data size and create buffer for contents.
      section.contents.resize(section.writePos + section.dataSize);
      LOG_TRACE(logger, "Section %zu allocated %zu bytes, data offset=%zu", i, section.contents.size(), section.writePos);
 
      // write subsection directory
      auto * ptr = (CogsBin3::SubSectionInfo*)section.contents.data();
      for (auto & subsection : section.subSections) {
        LOG_TRACE(logger, "  Subsection offset=%zu, size=%u, type=%u", subsection.offset, subsection.size, unsigned(subsection.type));
        ptr->offset = subsection.offset;
        ptr->size = subsection.size;
        ptr->type = subsection.type;
        ptr++;
      }
    }
  }
 
 
  template<typename T>
  void fillSubsection(WSection& section, uint32_t index, const std::vector<T>& source)
  {
    if (index == ~0u) return;
    auto & subSection = section.subSections[index];
    assert(sizeof(T)*source.size() == subSection.size);
 
    std::memcpy(section.contents.data() + subSection.offset, source.data(), subSection.size);
  }
 
  bool pack(Context* /*context*/, WriteContext& wctx)
  {
    // First section has meta data, and only this one can have subsections.
    auto & metaSection = getSection(wctx, CogsBin3::SectionType::META, 0);
 
    uint32_t subSections[size_t(CogsBin3::SubSectionType::EnumSize)];
    for (auto & subSection : subSections) subSection = (uint32_t)-1;
 
#define REGISTER(T,A) if(!(A).empty()) subSections[size_t(T)] = addMetaSubsection(wctx, metaSection, T, sizeof((A)[0])*((A).size()))
    REGISTER(CogsBin3::SubSectionType::Buffers, wctx.buffers);
    REGISTER(CogsBin3::SubSectionType::Textures, wctx.textures);
    REGISTER(CogsBin3::SubSectionType::Strings, wctx.strings);
    REGISTER(CogsBin3::SubSectionType::StringData, wctx.stringData);
    REGISTER(CogsBin3::SubSectionType::Nodes, wctx.nodes);
    REGISTER(CogsBin3::SubSectionType::Transforms, wctx.transforms);
    REGISTER(CogsBin3::SubSectionType::BoundingBoxes, wctx.boundingBoxes);
    REGISTER(CogsBin3::SubSectionType::MaterialInstances, wctx.materialInstances);
    REGISTER(CogsBin3::SubSectionType::Properties, wctx.properties);
    REGISTER(CogsBin3::SubSectionType::PropertyData, wctx.propertyData);
    REGISTER(CogsBin3::SubSectionType::Meshes, wctx.meshes);
    REGISTER(CogsBin3::SubSectionType::VertexStreams, wctx.vertexStreams);
    REGISTER(CogsBin3::SubSectionType::VertexAttributes, wctx.vertexAttributes);
    REGISTER(CogsBin3::SubSectionType::Bones, wctx.bones);
    REGISTER(CogsBin3::SubSectionType::Skeletons, wctx.skeletons);
    REGISTER(CogsBin3::SubSectionType::AnimTracks, wctx.animTracks);
    REGISTER(CogsBin3::SubSectionType::AnimClips, wctx.animClips);
    REGISTER(CogsBin3::SubSectionType::Models, wctx.models);
#undef REGISTER
 
    layoutSections(wctx);
 
    // copy contents of buffers
    for (size_t i = 0; i < wctx.buffers.size(); i++) {
      auto & buffer = wctx.buffers[i];
      const auto & bufCtx = wctx.bufferContexts[i];
      const auto lowerMask = uint64_t(bufCtx.alignment - 1);
 
      const auto sectionIx = buffer.sectionOffset;
      auto & section = getSection(wctx, CogsBin3::SectionType::DATA, uint16_t(sectionIx), false);
      auto offset = (section.writePos + lowerMask) & (~lowerMask);
      buffer.sectionOffset = offset | (sectionIx << 48);
 
      assert(offset + buffer.size <= section.contents.size());
      std::memcpy(section.contents.data() + offset, bufCtx.contents.data(), buffer.size);
      section.writePos = offset + buffer.size;
    }
 
    // copy contents of meta subsection
    fillSubsection(metaSection, subSections[size_t(CogsBin3::SubSectionType::Buffers)], wctx.buffers);
    fillSubsection(metaSection, subSections[size_t(CogsBin3::SubSectionType::Textures)], wctx.textures);
    fillSubsection(metaSection, subSections[size_t(CogsBin3::SubSectionType::Strings)], wctx.strings);
    fillSubsection(metaSection, subSections[size_t(CogsBin3::SubSectionType::StringData)], wctx.stringData);
    fillSubsection(metaSection, subSections[size_t(CogsBin3::SubSectionType::Nodes)], wctx.nodes);
    fillSubsection(metaSection, subSections[size_t(CogsBin3::SubSectionType::Transforms)], wctx.transforms);
    fillSubsection(metaSection, subSections[size_t(CogsBin3::SubSectionType::BoundingBoxes)], wctx.boundingBoxes);
    fillSubsection(metaSection, subSections[size_t(CogsBin3::SubSectionType::MaterialInstances)], wctx.materialInstances);
    fillSubsection(metaSection, subSections[size_t(CogsBin3::SubSectionType::Properties)], wctx.properties);
    fillSubsection(metaSection, subSections[size_t(CogsBin3::SubSectionType::PropertyData)], wctx.propertyData);
    fillSubsection(metaSection, subSections[size_t(CogsBin3::SubSectionType::Meshes)], wctx.meshes);
    fillSubsection(metaSection, subSections[size_t(CogsBin3::SubSectionType::VertexStreams)], wctx.vertexStreams);
    fillSubsection(metaSection, subSections[size_t(CogsBin3::SubSectionType::VertexAttributes)], wctx.vertexAttributes);
    fillSubsection(metaSection, subSections[size_t(CogsBin3::SubSectionType::Bones)], wctx.bones);
    fillSubsection(metaSection, subSections[size_t(CogsBin3::SubSectionType::Skeletons)], wctx.skeletons);
    fillSubsection(metaSection, subSections[size_t(CogsBin3::SubSectionType::AnimTracks)], wctx.animTracks);
    fillSubsection(metaSection, subSections[size_t(CogsBin3::SubSectionType::AnimClips)], wctx.animClips);
    fillSubsection(metaSection, subSections[size_t(CogsBin3::SubSectionType::Models)], wctx.models);
 
    return true;
  }
 
#if defined(_WIN32) && defined(MAKE_DEBUGABLE)
#pragma optimize( "", on )
#endif
  bool compressSections(Context* /*context*/, WriteContext& wctx)
  {
    wctx.sectionInfos.resize(wctx.sections.size());
    for (auto & section : wctx.sections) {
      auto & info = wctx.sectionInfos[section->index];              // Initialize section infos
      info.fileSize = section->contents.size();
      info.uncompressedSize = info.fileSize;
      info.compression = CogsBin3::Compression::None;
      info.type = section->type;
      info.subSectionCount = uint16_t(section->subSections.size());
    }
 
 
    if ((wctx.flags & WriteModelFlags::COMPRESS_ZSTD) != 0) {
 
      int compressionLevel = ZSTD_CLEVEL_DEFAULT;
      if ((wctx.flags & WriteModelFlags::COMPRESS_MAX) != 0) {
        compressionLevel = ZSTD_maxCLevel();
      } else {
        compressionLevel = wctx.settings.compressionLevel;
      }
 
      // Recycle context between sections. There is an opportunity for multi-threading with multiple sections.
      ZSTD_CCtx* zstd_ctx = ZSTD_createCCtx();
      if (zstd_ctx == nullptr) {
        LOG_ERROR(logger, "Failed to create zstd context.");
        return false;
      }
 
      std::vector<uint8_t> temp;
      for (auto & section : wctx.sections) {
        auto & info = wctx.sectionInfos[section->index];
        auto maxSize = ZSTD_compressBound(info.uncompressedSize);
        temp.resize(maxSize);
 
        // Run compression and check result
        auto result = ZSTD_compressCCtx(zstd_ctx, temp.data(), maxSize, section->contents.data(), info.uncompressedSize, compressionLevel);
        if (ZSTD_isError(result)) {
          LOG_ERROR(logger, "zstd compression failed: %s", ZSTD_getErrorName(result));
          continue;
        }
        else if (info.uncompressedSize <= result) {
          //LOG_DEBUG(logger, "compressed size is greater or equal to uncompressed size.");
          continue;
        }
 
        // Success, note compressed size etc.
        temp.resize(result);
        info.compression = CogsBin3::Compression::ZSTD;
        info.fileSize = result;
        section->contents.swap(temp);
      }
 
      ZSTD_freeCCtx(zstd_ctx);
      return true;
    }
    else {
      return true;  // No compression
    }
  }
#if defined(_WIN32) && defined(MAKE_DEBUGABLE)
#pragma optimize( "", off )
#endif
 
  bool write(Context* context, WriteContext& wctx)
  {
    pack(context, wctx);
 
    compressSections(context, wctx);
 
    // layout file and populate header
    uint64_t uncompressedSize = sizeof(CogsBin3::Header) + sizeof(CogsBin3::SectionInfo)*wctx.sectionInfos.size();
 
    CogsBin3::Header header{ };
    header.magic = CogsBin3::HeaderMagic;
    header.version = CogsBin3::Version;
    header.fileLength = sizeof(CogsBin3::Header) + sizeof(CogsBin3::SectionInfo) * wctx.sectionInfos.size();
    header.sectionCount = nextIndex(wctx.sectionInfos);
    for (auto & info : wctx.sectionInfos) {
      if (info.compression == CogsBin3::Compression::None) {
        // if no compression, align
        header.fileLength = (header.fileLength + (CogsBin3::CogsSectionAlignment - 1)) & ~(CogsBin3::CogsSectionAlignment - 1);
      }
      info.fileOffset = header.fileLength;
      header.fileLength += info.fileSize;
      uncompressedSize += info.uncompressedSize;
    }
 
    // write file.
    FILE * file = fopen(wctx.fileName.c_str(), "wb");
    if (file == nullptr) {
      LOG_ERROR(logger, "Failed to open \"%s\" for writing.", wctx.fileName.c_str());
      return false;
    }
 
    // write header
    auto r = fwrite(&header, sizeof(CogsBin3::Header), 1, file);
    if (r != 1){
      fclose(file);
      LOG_ERROR(logger, "Error writing to %s", wctx.fileName.c_str());
      return false;
    }
 
    // write section infos
    r = fwrite(wctx.sectionInfos.data(), sizeof(CogsBin3::SectionInfo)*header.sectionCount, 1, file);
    if (r != 1){
      fclose(file);
      LOG_ERROR(logger, "Error writing to %s", wctx.fileName.c_str());
      return false;
    }
 
    // write section contents
    for (uint32_t i = 0; i < header.sectionCount; i++) {
      auto & info = wctx.sectionInfos[i];
      auto & section = *wctx.sections[i].get();
 
#ifdef _WIN32
      auto pos = uint64_t(_ftelli64(file));
#else
      auto pos = uint64_t(ftell(file));
#endif
      assert(pos <= info.fileOffset);
      if (pos != info.fileOffset) {
#ifdef _WIN32
        _fseeki64(file, info.fileOffset, SEEK_SET);
#else
        fseek(file, info.fileOffset, SEEK_SET);
#endif
      }
 
      r = fwrite(section.contents.data(), info.fileSize, 1, file);
      if (r != 1){
        fclose(file);
        LOG_ERROR(logger, "Error writing to %s", wctx.fileName.c_str());
        return false;
      }
    }
 
#ifdef _WIN32
    auto fileLength = _ftelli64(file);
#else
    auto fileLength = ftell(file);
#endif
    assert(fileLength == (long long)header.fileLength);
    LOG_TRACE(logger, "Wrote %zu bytes (=%zu uncompressed, ratio=%.1f%%) (%u sections)",
              size_t(fileLength),
              size_t(uncompressedSize),
              (100.f*float(fileLength))/float(uncompressedSize),
              unsigned(header.sectionCount));
    fclose(file);
    return true;
  }
 
}
 
bool Cogs::Core::writeCogsBin3Model(Context * context, uint32_t & numVertes, uint32_t & numIndexes, const StringView & fileName, const Model * model, WriteModelSettings * settings)
{
  auto flags = settings->flags;
 
  if (!model) return false;
 
  WriteContext wctx{};
  wctx.fileName = fileName.to_string();
  wctx.flags = WriteModelFlags(flags);
  if (settings) {
    wctx.settings = *settings;
  }
  recordModel(wctx, model, flags);
  write(context, wctx);
  numVertes = wctx.numVertes;
  numIndexes = wctx.numIndexes;
  return true;
}
 
bool Cogs::Core::writeCogsBin3Models(Context * context, uint32_t& numVertes, uint32_t& numIndexes, const StringView & fileName, ComponentModel::Entity ** entity, size_t N, WriteModelFlags flags)
{
  if (!entity || N == 0) return false;
 
  uint16_t section = 0;
  WriteContext wctx{};
  wctx.fileName = fileName.to_string();
  wctx.flags = WriteModelFlags(flags);
  wctx.currentAnimation = nullptr;
  wctx.models.emplace_back(CogsBin3::Model{});
  auto & dstModel = wctx.models.back();
 
  dstModel.firstNode = recordEntity(context, wctx, ~0u, entity[0], section);
  for (size_t i = 1; i < N; i++) {
    recordEntity(context, wctx, ~0u, entity[i], section);
  }
  dstModel.nodeCount = uint32_t(wctx.nodes.size() - dstModel.firstNode);
 
  if (wctx.currentAnimation) {
    dstModel.skeleton = recordSkeleton(wctx, wctx.currentAnimation->skeleton);
    dstModel.animClipFirst = nextIndex(wctx.animClips);
    dstModel.animClipCount = uint32_t(wctx.currentAnimation->clips.size());
    for (const auto & clip : wctx.currentAnimation->clips) recordAnimClip(wctx, clip, section);
    assert(dstModel.animClipFirst + dstModel.animClipCount == wctx.animClips.size());
  }
  else {
    dstModel.skeleton = ~0u;
    dstModel.animClipFirst = ~0u;
    dstModel.animClipCount = 0;
  }
 
  write(context, wctx);
  numVertes = wctx.numVertes;
  numIndexes = wctx.numIndexes;
 
  return true;
}
 
#if defined(_WIN32) && defined(MAKE_DEBUGABLE)
#pragma optimize( "", on )
#endif
 
#else
// Emscripten
 
bool Cogs::Core::writeCogsBin3Model(Context * /*context*/, uint32_t & /*numVertes*/, uint32_t & /*numIndexes*/, const StringView & /*fileName*/, const Model * /*model*/, WriteModelSettings * /*settings*/)
{
  return false;
}
 
bool Cogs::Core::writeCogsBin3Models(Context * /*context*/, uint32_t& /*numVertes*/, uint32_t& /*numIndexes*/, const StringView & /*fileName*/, ComponentModel::Entity ** /*entity*/, size_t /*N*/, WriteModelFlags /*flags*/)
{
  return false;
}
 
#endif