ModelWriter.cpp

#include "ModelWriter.h"
#include "CogsBin.h"
#include "Context.h"
#include "Services/Variables.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 "Rendering/SamplerState.h"
 
#include "Foundation/HashSequence.h"
#include "Foundation/Logging/Logger.h"
#include "Foundation/Memory/MemoryBuffer.h"
#include "Foundation/Platform/IO.h"
#include "Foundation/Platform/Timer.h"
#include "Foundation/Reflection/TypeDatabase.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;
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("ModelWriter");
 
 
  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;
    CogsBin::SubSectionType   type;
  };
 
  struct WSection
  {
    CogsBin::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::CogsBin::Buffer> buffers;
    std::vector<Cogs::Core::CogsBin::ExternalTexture> externalTextures;
    std::vector<Cogs::Core::CogsBin::EmbeddedTexture> embeddedTextures;
    std::vector<Cogs::Core::CogsBin::SamplerState> samplerStates;
    std::vector<Cogs::Core::CogsBin::String> strings;
    std::vector<Cogs::Core::CogsBin::Property> properties;
    std::vector<Cogs::Core::CogsBin::MaterialInstance> materialInstances;
    std::vector<Cogs::Core::CogsBin::Transform> transforms;
    std::vector<Cogs::Geometry::BoundingBox> boundingBoxes;
    std::vector<Cogs::Core::CogsBin::Node> nodes;
    std::vector<Cogs::Core::CogsBin::Mesh> meshes;
    std::vector<Cogs::Core::CogsBin::VertexStream> vertexStreams;
    std::vector<Cogs::Core::CogsBin::VertexAttribute> vertexAttributes;
    std::vector<Cogs::Core::CogsBin::Bone> bones;
    std::vector<Cogs::Core::CogsBin::Skeleton> skeletons;
    std::vector<Cogs::Core::CogsBin::Model> models;
    std::vector<Cogs::Core::CogsBin::AnimTrack> animTracks;
    std::vector<Cogs::Core::CogsBin::AnimClip> animClips;
 
    std::vector<CogsBin::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 = CogsBin::CogsSectionAlignment - 1;
    return (x + m) & ~m;
  }
 
  CogsBin::PrimitiveType translatePrimitiveType(WriteContext& /*wctx*/, Cogs::PrimitiveType::EPrimitiveType primitiveType)
  {
    switch (primitiveType) {
    case Cogs::PrimitiveType::TriangleList:           return CogsBin::PrimitiveType::TriangleList; break;
    case Cogs::PrimitiveType::TriangleStrip:          return CogsBin::PrimitiveType::TriangleStrip; break;
    case Cogs::PrimitiveType::LineList:               return CogsBin::PrimitiveType::LineList; break;
    case Cogs::PrimitiveType::LineStrip:              return CogsBin::PrimitiveType::LineStrip; break;
    case Cogs::PrimitiveType::PointList:              return CogsBin::PrimitiveType::PointList; break;
    case Cogs::PrimitiveType::TriangleListAdjacency:  return CogsBin::PrimitiveType::TriangleListAdjacency; break;
    case Cogs::PrimitiveType::TriangleStripAdjacency: return CogsBin::PrimitiveType::TriangleStripAdjacency; break;
    case Cogs::PrimitiveType::LineListAdjacency:      return CogsBin::PrimitiveType::LineListAdjacency; break;
    case Cogs::PrimitiveType::LineStripAdjacency:     return CogsBin::PrimitiveType::LineStripAdjacency; break;
    case Cogs::PrimitiveType::ControlPoint1PatchList: return CogsBin::PrimitiveType::ControlPoint1PatchList; break;
    case Cogs::PrimitiveType::ControlPoint2PatchList: return CogsBin::PrimitiveType::ControlPoint2PatchList; break;
    case Cogs::PrimitiveType::ControlPoint3PatchList: return CogsBin::PrimitiveType::ControlPoint3PatchList; break;
    case Cogs::PrimitiveType::ControlPoint4PatchList: return CogsBin::PrimitiveType::ControlPoint4PatchList; break;
    default:
      break;
    }
    assert(false && "Illegal primitive type encountered");
    return CogsBin::PrimitiveType::TriangleList;
  }
 
  CogsBin::Format translateFormat(Cogs::TextureFormat format)
  {
    switch (format) {
    case Cogs::TextureFormat::Unknown:              return CogsBin::Format::Unknown; break;
    case Cogs::TextureFormat::R8_UNORM:             return CogsBin::Format::R8_UNORM; break;
    case Cogs::TextureFormat::R8G8_UNORM:           return CogsBin::Format::R8G8_UNORM; break;
    case Cogs::TextureFormat::R8G8B8_UNORM:         return CogsBin::Format::R8G8B8_UNORM; break;
    case Cogs::TextureFormat::R8G8B8A8_UNORM:       return CogsBin::Format::R8G8B8A8_UNORM; break;
    case Cogs::TextureFormat::R16_UNORM:            return CogsBin::Format::R16_UNORM; break;
    case Cogs::TextureFormat::R16G16_UNORM:         return CogsBin::Format::R16G16_UNORM; break;
    case Cogs::TextureFormat::R16G16B16_UNORM:      return CogsBin::Format::R16G16B16_UNORM; break;
    case Cogs::TextureFormat::R16G16B16A16_UNORM:   return CogsBin::Format::R16G16B16A16_UNORM; break;
    case Cogs::TextureFormat::R8_SNORM:             return CogsBin::Format::R8_SNORM; break;
    case Cogs::TextureFormat::R8G8_SNORM:           return CogsBin::Format::R8G8_SNORM; break;
    case Cogs::TextureFormat::R8G8B8_SNORM:         return CogsBin::Format::R8G8B8_SNORM; break;
    case Cogs::TextureFormat::R8G8B8A8_SNORM:       return CogsBin::Format::R8G8B8A8_SNORM; break;
    case Cogs::TextureFormat::R16_SNORM:            return CogsBin::Format::R16_SNORM; break;
    case Cogs::TextureFormat::R16G16_SNORM:         return CogsBin::Format::R16G16_SNORM; break;
    case Cogs::TextureFormat::R16G16B16_SNORM:      return CogsBin::Format::R16G16B16_SNORM; break;
    case Cogs::TextureFormat::R16G16B16A16_SNORM:   return CogsBin::Format::R16G16B16A16_SNORM; break;
    case Cogs::TextureFormat::R8_UINT:              return CogsBin::Format::R8_UINT; break;
    case Cogs::TextureFormat::R8G8_UINT:            return CogsBin::Format::R8G8_UINT; break;
    case Cogs::TextureFormat::R8G8B8_UINT:          return CogsBin::Format::R8G8B8_UINT; break;
    case Cogs::TextureFormat::R8G8B8A8_UINT:        return CogsBin::Format::R8G8B8A8_UINT; break;
    case Cogs::TextureFormat::R16_UINT:             return CogsBin::Format::R16_UINT; break;
    case Cogs::TextureFormat::R16G16_UINT:          return CogsBin::Format::R16G16_UINT; break;
    case Cogs::TextureFormat::R16G16B16_UINT:       return CogsBin::Format::R16G16B16_UINT; break;
    case Cogs::TextureFormat::R16G16B16A16_UINT:    return CogsBin::Format::R16G16B16A16_UINT; break;
    case Cogs::TextureFormat::R32_UINT:             return CogsBin::Format::R32_UINT; break;
    case Cogs::TextureFormat::R32G32_UINT:          return CogsBin::Format::R32G32_UINT; break;
    case Cogs::TextureFormat::R32G32B32_UINT:       return CogsBin::Format::R32G32B32_UINT; break;
    case Cogs::TextureFormat::R32G32B32A32_UINT:    return CogsBin::Format::R32G32B32A32_UINT; break;
    case Cogs::TextureFormat::R8_SINT:              return CogsBin::Format::R8_SINT; break;
    case Cogs::TextureFormat::R8G8_SINT:            return CogsBin::Format::R8G8_SINT; break;
    case Cogs::TextureFormat::R8G8B8_SINT:          return CogsBin::Format::R8G8B8_SINT; break;
    case Cogs::TextureFormat::R8G8B8A8_SINT:        return CogsBin::Format::R8G8B8A8_SINT; break;
    case Cogs::TextureFormat::R16_SINT:             return CogsBin::Format::R16_SINT; break;
    case Cogs::TextureFormat::R16G16_SINT:          return CogsBin::Format::R16G16_SINT; break;
    case Cogs::TextureFormat::R16G16B16_SINT:       return CogsBin::Format::R16G16B16_SINT; break;
    case Cogs::TextureFormat::R16G16B16A16_SINT:    return CogsBin::Format::R16G16B16A16_SINT; break;
    case Cogs::TextureFormat::R32_SINT:             return CogsBin::Format::R32_SINT; break;
    case Cogs::TextureFormat::R32G32_SINT:          return CogsBin::Format::R32G32_SINT; break;
    case Cogs::TextureFormat::R32G32B32_SINT:       return CogsBin::Format::R32G32B32_SINT; break;
    case Cogs::TextureFormat::R32G32B32A32_SINT:    return CogsBin::Format::R32G32B32A32_SINT; break;
    case Cogs::TextureFormat::R16_FLOAT:            return CogsBin::Format::R16_FLOAT; break;
    case Cogs::TextureFormat::R16G16_FLOAT:         return CogsBin::Format::R16G16_FLOAT; break;
    case Cogs::TextureFormat::R16G16B16_FLOAT:      return CogsBin::Format::R16G16B16_FLOAT; break;
    case Cogs::TextureFormat::R16G16B16A16_FLOAT:   return CogsBin::Format::R16G16B16A16_FLOAT; break;
    case Cogs::TextureFormat::R32_FLOAT:            return CogsBin::Format::R32_FLOAT; break;
    case Cogs::TextureFormat::R32G32_FLOAT:         return CogsBin::Format::R32G32_FLOAT; break;
    case Cogs::TextureFormat::R32G32B32_FLOAT:      return CogsBin::Format::R32G32B32_FLOAT; break;
    case Cogs::TextureFormat::R32G32B32A32_FLOAT:   return CogsBin::Format::R32G32B32A32_FLOAT; break;
    case Cogs::TextureFormat::D16_UNORM:            return CogsBin::Format::D16_UNORM; break;
    case Cogs::TextureFormat::D24_UNORM:            return CogsBin::Format::D24_UNORM; break;
    case Cogs::TextureFormat::D24S8_UNORM:          return CogsBin::Format::D24S8_UNORM; break;
    case Cogs::TextureFormat::D32_FLOAT:            return CogsBin::Format::D32_FLOAT; break;
    case Cogs::TextureFormat::R32_TYPELESS:         return CogsBin::Format::R32_TYPELESS; break;
    case Cogs::TextureFormat::R16_TYPELESS:         return CogsBin::Format::R16_TYPELESS; break;
    case Cogs::TextureFormat::R8T:                  return CogsBin::Format::R8T; break;
    case Cogs::TextureFormat::R8G8T:                return CogsBin::Format::R8G8T; break;
    case Cogs::TextureFormat::R8G8B8T:              return CogsBin::Format::R8G8B8T; break;
    case Cogs::TextureFormat::R8G8B8A8T:            return CogsBin::Format::R8G8B8A8T; break;
    case Cogs::TextureFormat::B8G8R8:               return CogsBin::Format::B8G8R8; break;
    case Cogs::TextureFormat::B8G8R8A8:             return CogsBin::Format::B8G8R8A8; break;
    case Cogs::TextureFormat::A8_UNORM:             return CogsBin::Format::A8_UNORM; break;
    case Cogs::TextureFormat::BC1_TYPELESS:         return CogsBin::Format::BC1_TYPELESS; break;
    case Cogs::TextureFormat::BC1_UNORM:            return CogsBin::Format::BC1_UNORM; break;
    case Cogs::TextureFormat::BC1_UNORM_SRGB:       return CogsBin::Format::BC1_UNORM_SRGB; break;
    case Cogs::TextureFormat::BC2_TYPELESS:         return CogsBin::Format::BC2_TYPELESS; break;
    case Cogs::TextureFormat::BC2_UNORM:            return CogsBin::Format::BC2_UNORM; break;
    case Cogs::TextureFormat::BC2_UNORM_SRGB:       return CogsBin::Format::BC2_UNORM_SRGB; break;
    case Cogs::TextureFormat::BC3_TYPELESS:         return CogsBin::Format::BC3_TYPELESS; break;
    case Cogs::TextureFormat::BC3_UNORM:            return CogsBin::Format::BC3_UNORM; break;
    case Cogs::TextureFormat::BC3_UNORM_SRGB:       return CogsBin::Format::BC3_UNORM_SRGB; break;
    case Cogs::TextureFormat::BC4_TYPELESS:         return CogsBin::Format::BC4_TYPELESS; break;
    case Cogs::TextureFormat::BC4_UNORM:            return CogsBin::Format::BC4_UNORM; break;
    case Cogs::TextureFormat::BC4_SNORM:            return CogsBin::Format::BC4_SNORM; break;
    case Cogs::TextureFormat::BC5_TYPELESS:         return CogsBin::Format::BC5_TYPELESS; break;
    case Cogs::TextureFormat::BC5_UNORM:            return CogsBin::Format::BC5_UNORM; break;
    case Cogs::TextureFormat::BC5_SNORM:            return CogsBin::Format::BC5_SNORM; break;
    case Cogs::TextureFormat::R8G8B8A8_UNORM_SRGB:  return CogsBin::Format::R8G8B8A8_UNORM_SRGB; break;
    default:
      assert(false && "Illegal format");
      break;
    }
    return CogsBin::Format::Unknown;
  }
 
  CogsBin::DataFormatV5 translateDataFormat(Cogs::DataFormat fmt)
  {
    switch (fmt) {
    case Cogs::DataFormat::Unknown: return CogsBin::DataFormatV5::Unknown;
    case Cogs::DataFormat::R8_UNORM: return CogsBin::DataFormatV5::R8_UNORM;
    case Cogs::DataFormat::R8G8_UNORM: return CogsBin::DataFormatV5::R8G8_UNORM;
    case Cogs::DataFormat::R8G8B8_UNORM: return CogsBin::DataFormatV5::R8G8B8_UNORM;
    case Cogs::DataFormat::R8G8B8A8_UNORM: return CogsBin::DataFormatV5::R8G8B8A8_UNORM;
    case Cogs::DataFormat::R16_UNORM: return CogsBin::DataFormatV5::R16_UNORM;
    case Cogs::DataFormat::R16G16_UNORM: return CogsBin::DataFormatV5::R16G16_UNORM;
    case Cogs::DataFormat::R16G16B16_UNORM: return CogsBin::DataFormatV5::R16G16B16_UNORM;
    case Cogs::DataFormat::R16G16B16A16_UNORM: return CogsBin::DataFormatV5::R16G16B16A16_UNORM;
    case Cogs::DataFormat::R8_SNORM: return CogsBin::DataFormatV5::R8_SNORM;
    case Cogs::DataFormat::R8G8_SNORM: return CogsBin::DataFormatV5::R8G8_SNORM;
    case Cogs::DataFormat::R8G8B8_SNORM: return CogsBin::DataFormatV5::R8G8B8_SNORM;
    case Cogs::DataFormat::R8G8B8A8_SNORM: return CogsBin::DataFormatV5::R8G8B8A8_SNORM;
    case Cogs::DataFormat::R16_SNORM: return CogsBin::DataFormatV5::R16_SNORM;
    case Cogs::DataFormat::R16G16_SNORM: return CogsBin::DataFormatV5::R16G16_SNORM;
    case Cogs::DataFormat::R16G16B16_SNORM: return CogsBin::DataFormatV5::R16G16B16_SNORM;
    case Cogs::DataFormat::R16G16B16A16_SNORM: return CogsBin::DataFormatV5::R16G16B16A16_SNORM;
    case Cogs::DataFormat::R8_UINT: return CogsBin::DataFormatV5::R8_UINT;
    case Cogs::DataFormat::R8G8_UINT: return CogsBin::DataFormatV5::R8G8_UINT;
    case Cogs::DataFormat::R8G8B8_UINT: return CogsBin::DataFormatV5::R8G8B8_UINT;
    case Cogs::DataFormat::R8G8B8A8_UINT: return CogsBin::DataFormatV5::R8G8B8A8_UINT;
    case Cogs::DataFormat::R16_UINT: return CogsBin::DataFormatV5::R16_UINT;
    case Cogs::DataFormat::R16G16_UINT: return CogsBin::DataFormatV5::R16G16_UINT;
    case Cogs::DataFormat::R16G16B16_UINT: return CogsBin::DataFormatV5::R16G16B16_UINT;
    case Cogs::DataFormat::R16G16B16A16_UINT: return CogsBin::DataFormatV5::R16G16B16A16_UINT;
    case Cogs::DataFormat::R32_UINT: return CogsBin::DataFormatV5::R32_UINT;
    case Cogs::DataFormat::R32G32_UINT: return CogsBin::DataFormatV5::R32G32_UINT;
    case Cogs::DataFormat::R32G32B32_UINT: return CogsBin::DataFormatV5::R32G32B32_UINT;
    case Cogs::DataFormat::R32G32B32A32_UINT: return CogsBin::DataFormatV5::R32G32B32A32_UINT;
    case Cogs::DataFormat::R8_SINT: return CogsBin::DataFormatV5::R8_SINT;
    case Cogs::DataFormat::R8G8_SINT: return CogsBin::DataFormatV5::R8G8_SINT;
    case Cogs::DataFormat::R8G8B8_SINT: return CogsBin::DataFormatV5::R8G8B8_SINT;
    case Cogs::DataFormat::R8G8B8A8_SINT: return CogsBin::DataFormatV5::R8G8B8A8_SINT;
    case Cogs::DataFormat::R16_SINT: return CogsBin::DataFormatV5::R16_SINT;
    case Cogs::DataFormat::R16G16_SINT: return CogsBin::DataFormatV5::R16G16_SINT;
    case Cogs::DataFormat::R16G16B16_SINT: return CogsBin::DataFormatV5::R16G16B16_SINT;
    case Cogs::DataFormat::R16G16B16A16_SINT: return CogsBin::DataFormatV5::R16G16B16A16_SINT;
    case Cogs::DataFormat::R32_SINT: return CogsBin::DataFormatV5::R32_SINT;
    case Cogs::DataFormat::R32G32_SINT: return CogsBin::DataFormatV5::R32G32_SINT;
    case Cogs::DataFormat::R32G32B32_SINT: return CogsBin::DataFormatV5::R32G32B32_SINT;
    case Cogs::DataFormat::R32G32B32A32_SINT: return CogsBin::DataFormatV5::R32G32B32A32_SINT;
    case Cogs::DataFormat::R16_FLOAT: return CogsBin::DataFormatV5::R16_FLOAT;
    case Cogs::DataFormat::R16G16_FLOAT: return CogsBin::DataFormatV5::R16G16_FLOAT;
    case Cogs::DataFormat::R16G16B16_FLOAT: return CogsBin::DataFormatV5::R16G16B16_FLOAT;
    case Cogs::DataFormat::R16G16B16A16_FLOAT: return CogsBin::DataFormatV5::R16G16B16A16_FLOAT;
    case Cogs::DataFormat::R32_FLOAT: return CogsBin::DataFormatV5::R32_FLOAT;
    case Cogs::DataFormat::R32G32_FLOAT: return CogsBin::DataFormatV5::R32G32_FLOAT;
    case Cogs::DataFormat::R32G32B32_FLOAT: return CogsBin::DataFormatV5::R32G32B32_FLOAT;
    case Cogs::DataFormat::R32G32B32A32_FLOAT: return CogsBin::DataFormatV5::R32G32B32A32_FLOAT;
    case Cogs::DataFormat::D16_UNORM: return CogsBin::DataFormatV5::D16_UNORM;
    case Cogs::DataFormat::D24_UNORM: return CogsBin::DataFormatV5::D24_UNORM;
    case Cogs::DataFormat::D24S8_UNORM: return CogsBin::DataFormatV5::D24S8_UNORM;
    case Cogs::DataFormat::D32_FLOAT: return CogsBin::DataFormatV5::D32_FLOAT;
    case Cogs::DataFormat::R32_TYPELESS: return CogsBin::DataFormatV5::R32_TYPELESS;
    case Cogs::DataFormat::R16_TYPELESS: return CogsBin::DataFormatV5::R16_TYPELESS;
    case Cogs::DataFormat::R8T: return CogsBin::DataFormatV5::R8T;
    case Cogs::DataFormat::R8G8T: return CogsBin::DataFormatV5::R8G8T;
    case Cogs::DataFormat::R8G8B8T: return CogsBin::DataFormatV5::R8G8B8T;
    case Cogs::DataFormat::R8G8B8A8T: return CogsBin::DataFormatV5::R8G8B8A8T;
    case Cogs::DataFormat::B8G8R8: return CogsBin::DataFormatV5::B8G8R8;
    case Cogs::DataFormat::B8G8R8A8: return CogsBin::DataFormatV5::B8G8R8A8;
    case Cogs::DataFormat::A8_UNORM: return CogsBin::DataFormatV5::A8_UNORM;
    case Cogs::DataFormat::BC1_TYPELESS: return CogsBin::DataFormatV5::BC1_TYPELESS;
    case Cogs::DataFormat::BC1_UNORM: return CogsBin::DataFormatV5::BC1_UNORM;
    case Cogs::DataFormat::BC1_UNORM_SRGB: return CogsBin::DataFormatV5::BC1_UNORM_SRGB;
    case Cogs::DataFormat::BC2_TYPELESS: return CogsBin::DataFormatV5::BC2_TYPELESS;
    case Cogs::DataFormat::BC2_UNORM: return CogsBin::DataFormatV5::BC2_UNORM;
    case Cogs::DataFormat::BC2_UNORM_SRGB: return CogsBin::DataFormatV5::BC2_UNORM_SRGB;
    case Cogs::DataFormat::BC3_TYPELESS: return CogsBin::DataFormatV5::BC3_TYPELESS;
    case Cogs::DataFormat::BC3_UNORM: return CogsBin::DataFormatV5::BC3_UNORM;
    case Cogs::DataFormat::BC3_UNORM_SRGB: return CogsBin::DataFormatV5::BC3_UNORM_SRGB;
    case Cogs::DataFormat::BC4_TYPELESS: return CogsBin::DataFormatV5::BC4_TYPELESS;
    case Cogs::DataFormat::BC4_UNORM: return CogsBin::DataFormatV5::BC4_UNORM;
    case Cogs::DataFormat::BC4_SNORM: return CogsBin::DataFormatV5::BC4_SNORM;
    case Cogs::DataFormat::BC5_TYPELESS: return CogsBin::DataFormatV5::BC5_TYPELESS;
    case Cogs::DataFormat::BC5_UNORM: return CogsBin::DataFormatV5::BC5_UNORM;
    case Cogs::DataFormat::BC5_SNORM: return CogsBin::DataFormatV5::BC5_SNORM;
    case Cogs::DataFormat::BC6H_SIGNED_FLOAT_RGB: return CogsBin::DataFormatV5::BC6H_SIGNED_FLOAT_RGB;
    case Cogs::DataFormat::BC6H_UNSIGNED_FLOAT_RGB: return CogsBin::DataFormatV5::BC6H_UNSIGNED_FLOAT_RGB;
    case Cogs::DataFormat::BC7_UNORM_RGBA: return CogsBin::DataFormatV5::BC7_UNORM_RGBA;
    case Cogs::DataFormat::BC7_UNORM_SRGBA: return CogsBin::DataFormatV5::BC7_UNORM_SRGBA;
    case Cogs::DataFormat::PVRTC1_2BPP_UNORM_RGB: return CogsBin::DataFormatV5::PVRTC1_2BPP_UNORM_RGB;
    case Cogs::DataFormat::PVRTC1_4BPP_UNORM_RGB: return CogsBin::DataFormatV5::PVRTC1_4BPP_UNORM_RGB;
    case Cogs::DataFormat::PVRTC1_2BPP_UNORM_RGBA: return CogsBin::DataFormatV5::PVRTC1_2BPP_UNORM_RGBA;
    case Cogs::DataFormat::PVRTC1_4BPP_UNORM_RGBA: return CogsBin::DataFormatV5::PVRTC1_4BPP_UNORM_RGBA;
    case Cogs::DataFormat::EAC_BLOCK8_UNSIGNED_FLOAT_R: return CogsBin::DataFormatV5::EAC_BLOCK8_UNSIGNED_FLOAT_R;
    case Cogs::DataFormat::EAC_BLOCK8_SIGNED_FLOAT_R: return CogsBin::DataFormatV5::EAC_BLOCK8_SIGNED_FLOAT_R;
    case Cogs::DataFormat::EAC_BLOCK16_UNSIGNED_FLOAT_RG: return CogsBin::DataFormatV5::EAC_BLOCK16_UNSIGNED_FLOAT_RG;
    case Cogs::DataFormat::EAC_BLOCK16_SIGNED_FLOAT_RG: return CogsBin::DataFormatV5::EAC_BLOCK16_SIGNED_FLOAT_RG;
    case Cogs::DataFormat::ETC2_BLOCK8_UNORM_RGB: return CogsBin::DataFormatV5::ETC2_BLOCK8_UNORM_RGB;
    case Cogs::DataFormat::ETC2_BLOCK8_UNORM_SRGB: return CogsBin::DataFormatV5::ETC2_BLOCK8_UNORM_SRGB;
    case Cogs::DataFormat::ETC2_BLOCK16_UNORM_RGBA: return CogsBin::DataFormatV5::ETC2_BLOCK16_UNORM_RGBA;
    case Cogs::DataFormat::ETC2_BLOCK16_UNORM_SRGBA: return CogsBin::DataFormatV5::ETC2_BLOCK16_UNORM_SRGBA;
    case Cogs::DataFormat::ASTC_4x4_UNORM_RGBA: return CogsBin::DataFormatV5::ASTC_4x4_UNORM_RGBA;
    case Cogs::DataFormat::ASTC_5x4_UNORM_RGBA: return CogsBin::DataFormatV5::ASTC_5x4_UNORM_RGBA;
    case Cogs::DataFormat::ASTC_5x5_UNORM_RGBA: return CogsBin::DataFormatV5::ASTC_5x5_UNORM_RGBA;
    case Cogs::DataFormat::ASTC_6x5_UNORM_RGBA: return CogsBin::DataFormatV5::ASTC_6x5_UNORM_RGBA;
    case Cogs::DataFormat::ASTC_6x6_UNORM_RGBA: return CogsBin::DataFormatV5::ASTC_6x6_UNORM_RGBA;
    case Cogs::DataFormat::ASTC_8x5_UNORM_RGBA: return CogsBin::DataFormatV5::ASTC_8x5_UNORM_RGBA;
    case Cogs::DataFormat::ASTC_8x6_UNORM_RGBA: return CogsBin::DataFormatV5::ASTC_8x6_UNORM_RGBA;
    case Cogs::DataFormat::ASTC_8x8_UNORM_RGBA: return CogsBin::DataFormatV5::ASTC_8x8_UNORM_RGBA;
    case Cogs::DataFormat::ASTC_10x5_UNORM_RGBA: return CogsBin::DataFormatV5::ASTC_10x5_UNORM_RGBA;
    case Cogs::DataFormat::ASTC_10x6_UNORM_RGBA: return CogsBin::DataFormatV5::ASTC_10x6_UNORM_RGBA;
    case Cogs::DataFormat::ASTC_10x8_UNORM_RGBA: return CogsBin::DataFormatV5::ASTC_10x8_UNORM_RGBA;
    case Cogs::DataFormat::ASTC_10x10_UNORM_RGBA: return CogsBin::DataFormatV5::ASTC_10x10_UNORM_RGBA;
    case Cogs::DataFormat::ASTC_12x10_UNORM_RGBA: return CogsBin::DataFormatV5::ASTC_12x10_UNORM_RGBA;
    case Cogs::DataFormat::ASTC_12x12_UNORM_RGBA: return CogsBin::DataFormatV5::ASTC_12x12_UNORM_RGBA;
    case Cogs::DataFormat::ASTC_4x4_UNORM_SRGBA: return CogsBin::DataFormatV5::ASTC_4x4_UNORM_SRGBA;
    case Cogs::DataFormat::ASTC_5x4_UNORM_SRGBA: return CogsBin::DataFormatV5::ASTC_5x4_UNORM_SRGBA;
    case Cogs::DataFormat::ASTC_5x5_UNORM_SRGBA: return CogsBin::DataFormatV5::ASTC_5x5_UNORM_SRGBA;
    case Cogs::DataFormat::ASTC_6x5_UNORM_SRGBA: return CogsBin::DataFormatV5::ASTC_6x5_UNORM_SRGBA;
    case Cogs::DataFormat::ASTC_6x6_UNORM_SRGBA: return CogsBin::DataFormatV5::ASTC_6x6_UNORM_SRGBA;
    case Cogs::DataFormat::ASTC_8x5_UNORM_SRGBA: return CogsBin::DataFormatV5::ASTC_8x5_UNORM_SRGBA;
    case Cogs::DataFormat::ASTC_8x6_UNORM_SRGBA: return CogsBin::DataFormatV5::ASTC_8x6_UNORM_SRGBA;
    case Cogs::DataFormat::ASTC_8x8_UNORM_SRGBA: return CogsBin::DataFormatV5::ASTC_8x8_UNORM_SRGBA;
    case Cogs::DataFormat::ASTC_10x5_UNORM_SRGBA: return CogsBin::DataFormatV5::ASTC_10x5_UNORM_SRGBA;
    case Cogs::DataFormat::ASTC_10x6_UNORM_SRGBA: return CogsBin::DataFormatV5::ASTC_10x6_UNORM_SRGBA;
    case Cogs::DataFormat::ASTC_10x8_UNORM_SRGBA: return CogsBin::DataFormatV5::ASTC_10x8_UNORM_SRGBA;
    case Cogs::DataFormat::ASTC_10x10_UNORM_SRGBA: return CogsBin::DataFormatV5::ASTC_10x10_UNORM_SRGBA;
    case Cogs::DataFormat::ASTC_12x10_UNORM_SRGBA: return CogsBin::DataFormatV5::ASTC_12x10_UNORM_SRGBA;
    case Cogs::DataFormat::ASTC_12x12_UNORM_SRGBA: return CogsBin::DataFormatV5::ASTC_12x12_UNORM_SRGBA;
    case Cogs::DataFormat::R8G8B8_UNORM_SRGB: return CogsBin::DataFormatV5::R8G8B8_UNORM_SRGB;
    case Cogs::DataFormat::R8G8B8A8_UNORM_SRGB: return CogsBin::DataFormatV5::R8G8B8A8_UNORM_SRGB;
    case Cogs::DataFormat::R10G10B10A2_TYPELESS: return CogsBin::DataFormatV5::R10G10B10A2_TYPELESS;
    case Cogs::DataFormat::R10G10B10A2_UNORM: return CogsBin::DataFormatV5::R10G10B10A2_UNORM;
    case Cogs::DataFormat::R10G10B10A2_UINT: return CogsBin::DataFormatV5::R10G10B10A2_UINT;
    case Cogs::DataFormat::R11G11B10_FLOAT: return CogsBin::DataFormatV5::R11G11B10_FLOAT;
    case Cogs::DataFormat::R5G6B5_UNORM: return CogsBin::DataFormatV5::R5G6B5_UNORM;
    case Cogs::DataFormat::R5G5B5A1_UNORM: return CogsBin::DataFormatV5::R5G5B5A1_UNORM;
    case Cogs::DataFormat::R4G4B4A4_UNORM: return CogsBin::DataFormatV5::R4G4B4A4_UNORM;
    case Cogs::DataFormat::R9G9B9E5_FLOAT: return CogsBin::DataFormatV5::R9G9B9E5_FLOAT;
    case Cogs::DataFormat::MAT4X4_FLOAT: return CogsBin::DataFormatV5::MAT4X4_FLOAT;
    default:
      assert(false && "Invalid data format");
      return CogsBin::DataFormatV5::Unknown;
    }
  }
 
  CogsBin::TextureDimensions translateTextureDimensions(Cogs::ResourceDimensions dimensions)
  {
    switch (dimensions) {
    case Cogs::ResourceDimensions::Unknown:          return CogsBin::TextureDimensions::Unknown; break;
    case Cogs::ResourceDimensions::Buffer:           return CogsBin::TextureDimensions::Buffer; break;
    case Cogs::ResourceDimensions::Texture1D:        return CogsBin::TextureDimensions::Texture1D; break;
    case Cogs::ResourceDimensions::Texture1DArray:   return CogsBin::TextureDimensions::Texture1DArray; break;
    case Cogs::ResourceDimensions::Texture2D:        return CogsBin::TextureDimensions::Texture2D; break;
    case Cogs::ResourceDimensions::Texture2DArray:   return CogsBin::TextureDimensions::Texture2DArray; break;
    case Cogs::ResourceDimensions::Texture2DMS:      return CogsBin::TextureDimensions::Texture2DMS; break;
    case Cogs::ResourceDimensions::Texture2DMSArray: return CogsBin::TextureDimensions::Texture2DMSArray; break;
    case Cogs::ResourceDimensions::Texture3D:        return CogsBin::TextureDimensions::Texture3D; break;
    case Cogs::ResourceDimensions::Texture3DArray:   return CogsBin::TextureDimensions::Texture3DArray; break;
    case Cogs::ResourceDimensions::TextureCube:      return CogsBin::TextureDimensions::TextureCube; break;
    case Cogs::ResourceDimensions::TextureCubeArray: return CogsBin::TextureDimensions::TextureCubeArray; break;
    default:
      assert(false && "Illegal texture dimension");
      break;
    }
    return CogsBin::TextureDimensions::Unknown;
  }
 
  CogsBin::TextureAddressMode translateTextureAddressMode(Cogs::SamplerState::AddressMode addressMode)
  {
    switch (addressMode) {
    case Cogs::SamplerState::AddressMode::Clamp:  return CogsBin::TextureAddressMode::Clamp; break;
    case Cogs::SamplerState::AddressMode::Wrap:   return CogsBin::TextureAddressMode::Wrap; break;
    case Cogs::SamplerState::AddressMode::Mirror: return CogsBin::TextureAddressMode::Mirror; break;
    case Cogs::SamplerState::AddressMode::Border: return CogsBin::TextureAddressMode::Border; break;
    default:
      assert(false && "Illegal texture addressing mode");
      break;
    }
    return CogsBin::TextureAddressMode::Wrap;
  }
 
  CogsBin::TextureFilterMode translateTextureFilterMode(Cogs::SamplerState::FilterMode filterMode)
  {
    switch (filterMode) {
    case Cogs::SamplerState::FilterMode::MinMagMipPoint:            return CogsBin::TextureFilterMode::MinMagMipPoint; break;
    case Cogs::SamplerState::FilterMode::MinMagMipLinear:           return CogsBin::TextureFilterMode::MinMagMipLinear; break;
    case Cogs::SamplerState::FilterMode::ComparisonMinMagMipPoint:  return CogsBin::TextureFilterMode::ComparisonMinMagMipPoint; break;
    case Cogs::SamplerState::FilterMode::ComparisonMinMagMipLinear: return CogsBin::TextureFilterMode::ComparisonMinMagMipLinear; break;
    default:
      assert(false && "Illegal texture filter mode");
      break;
    }
    return CogsBin::TextureFilterMode::MinMagMipLinear;
  }
 
  CogsBin::TextureComparisonFunction translateTextureComparisonFunc(Cogs::SamplerState::ComparisonFunction compFunc)
  {
    switch (compFunc) {
    case Cogs::SamplerState::ComparisonFunction::Never:        return CogsBin::TextureComparisonFunction::Never; break;
    case Cogs::SamplerState::ComparisonFunction::Less:         return CogsBin::TextureComparisonFunction::Less; break;
    case Cogs::SamplerState::ComparisonFunction::Equal:        return CogsBin::TextureComparisonFunction::Equal; break;
    case Cogs::SamplerState::ComparisonFunction::LessEqual:    return CogsBin::TextureComparisonFunction::LessEqual; break;
    case Cogs::SamplerState::ComparisonFunction::Greater:      return CogsBin::TextureComparisonFunction::Greater; break;
    case Cogs::SamplerState::ComparisonFunction::NotEqual:     return CogsBin::TextureComparisonFunction::NotEqual; break;
    case Cogs::SamplerState::ComparisonFunction::GreaterEqual: return CogsBin::TextureComparisonFunction::GreaterEqual; break;
    case Cogs::SamplerState::ComparisonFunction::Always:       return CogsBin::TextureComparisonFunction::Always; break;
    default:
      assert(false && "Illegal texture comparison function");
      break;
    }
    return CogsBin::TextureComparisonFunction::Never;
  }
 
  WSection& getSection(WriteContext& wctx, CogsBin::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, CogsBin::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 = CogsBin::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);
    CogsBin::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 = material->getTextureProperty(DefaultMaterial::DiffuseMap).hash(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(CogsBin::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(CogsBin::VertexAttribute{});
    auto & attribute = wctx.vertexAttributes.back();
 
    attribute.offset = uint16_t(element.offset);
    attribute.format = static_cast<CogsBin::Format>(translateDataFormat(element.format));
 
    switch (element.semantic) {
    case Cogs::ElementSemantic::Position:           attribute.semantic = CogsBin::Semantic::Position; break;
    case Cogs::ElementSemantic::Normal:             attribute.semantic = CogsBin::Semantic::Normal; break;
    case Cogs::ElementSemantic::Color:              attribute.semantic = CogsBin::Semantic::Color; break;
    case Cogs::ElementSemantic::TextureCoordinate:  attribute.semantic = CogsBin::Semantic::TexCoord; break;
    case Cogs::ElementSemantic::Tangent:            attribute.semantic = CogsBin::Semantic::Tangent; break;
    case Cogs::ElementSemantic::InstanceVector:     attribute.semantic = CogsBin::Semantic::InstanceVector; break;
    case Cogs::ElementSemantic::InstanceMatrix:     attribute.semantic = CogsBin::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 = std::max(uint16_t(1), element.instanceStep);
    }
    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, CogsBin::BufferContentFlags flags, uint32_t alignment, uint16_t sectionIx)
  {
    assert(alignment);
    assert(size);
    assert(alignment <= CogsBin::CogsSectionAlignment);
 
    const auto lowerMask = uint64_t(alignment - 1);
 
    auto & section = getSection(wctx, CogsBin::SectionType::DATA, sectionIx);
    section.dataSize = (section.dataSize + lowerMask)&(~lowerMask);
    section.dataSize += size;
 
    auto index = nextIndex(wctx.buffers);
    wctx.buffers.emplace_back(CogsBin::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;
    }
 
    CogsBin::BufferContentFlags flags = CogsBin::BufferContentFlags::None;
    if (srcBuffer->isVertexBuffer()) flags |= CogsBin::BufferContentFlags::VertexData;
    if (srcBuffer->isIndexBuffer()) flags |= CogsBin::BufferContentFlags::IndexData;
 
    constexpr uint32_t bufferStride = 16;
    auto alignment = std::min(uint32_t(CogsBin::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, CogsBin::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(CogsBin::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() ? CogsBin::MeshFlags::None : CogsBin::MeshFlags::Clockwise) |
      (srcMesh->isMeshFlagSet(MeshFlags::Skinned) ? CogsBin::MeshFlags::Skinned : CogsBin::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, CogsBin::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 == CogsBin::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(CogsBin::Property{ CogsBin::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, CogsBin::PropertyValueType valueType, const Cogs::StringView& value)
  {
    auto index = nextIndex(wctx.properties);
    wctx.properties.emplace_back();
    auto & prop = wctx.properties.back();
    prop.keyType = CogsBin::PropertyKeyType::String;
    prop.key = recordString(wctx, key);
    prop.valueType = valueType;
    prop.value = recordString(wctx, value);
    return index;
  }
 
  uint32_t recordSamplerState(WriteContext& wctx, const TextureWithSampler& srcSampler) {
    auto index = nextIndex(wctx.samplerStates);
    wctx.samplerStates.emplace_back();
    auto& samplerState = wctx.samplerStates.back();
    samplerState.addressModeS = translateTextureAddressMode(srcSampler.sMode);
    samplerState.addressModeT = translateTextureAddressMode(srcSampler.tMode);
    samplerState.addressModeW = translateTextureAddressMode(srcSampler.uMode);
    samplerState.filter = translateTextureFilterMode(srcSampler.filterMode);
 
    // Fill in default properties that we don't currently have in TextureWithSampler
    const Cogs::SamplerState& defaultState = Cogs::SamplerState::DefaultState();
    samplerState.comparisonFunction = translateTextureComparisonFunc(defaultState.comparisonFunction);
    samplerState.maxAnisotropy = defaultState.maxAnisotropy;
    std::copy(std::begin(defaultState.borderColor), std::end(defaultState.borderColor), samplerState.borderColor);
 
    return index;
  }
 
  uint32_t recordEmbeddedTexture(WriteContext& wctx, const Texture* srcTex, uint32_t samplerIx, 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.embeddedTextures);
    wctx.knownTexturesByPointer[srcTex] = texIx;
    auto & dstTex = wctx.embeddedTextures.emplace_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, CogsBin::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 = CogsBin::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 = CogsBin::TextureFlags::None;
    dstTex.dimension = translateTextureDimensions(srcTex->description.target);
    dstTex.samplerState = samplerIx;
 
    return texIx;
  }
 
  uint32_t recordMaterialOptions(WriteContext& wctx, const MaterialOptions& options) {
    uint32_t propCount = 0;
    Cogs::StringView optionVal;
    switch(options.cullMode) {
      case CullMode::None:  optionVal = "None"; break;
      case CullMode::Back:  optionVal = "Back"; break;
      case CullMode::Front: optionVal = "Front"; break;
      default: assert(false && "Invalid cull mode"); break;
    }
    recordStringBasedProperty(wctx, "CullMode", CogsBin::PropertyValueType::Option, optionVal);
    propCount++;
 
    const Cogs::Reflection::Enumerator* blendMode = Cogs::Reflection::TypeDatabase::getType<BlendMode>().getEnumerator(size_t(options.blendMode));
    assert(blendMode && "Invalid blend mode");
    optionVal = blendMode->getName().c_str();
 
    recordStringBasedProperty(wctx, "BlendMode", CogsBin::PropertyValueType::Option, optionVal);
    propCount++;
 
    switch(options.transparencyMode) {
      case TransparencyMode::On:    optionVal = "On"; break;
      case TransparencyMode::Off:   optionVal = "Off"; break;
      case TransparencyMode::Auto:  optionVal = "Auto"; break;
      case TransparencyMode::Alpha: optionVal = "Alpha"; break;
      default: assert(false && "Invalid transparency mode"); break;
    }
    recordStringBasedProperty(wctx, "Transparency", CogsBin::PropertyValueType::Option, optionVal);
    propCount++;
 
    recordStringBasedProperty(wctx, "DepthWriteEnabled", CogsBin::PropertyValueType::Option, options.depthWriteEnabled ? "true" : "false");
    recordStringBasedProperty(wctx, "DepthTestEnabled", CogsBin::PropertyValueType::Option, options.depthTestEnabled ? "true" : "false");
 
    switch (options.depthFunc) {
      case DepthFunc::Less:    optionVal = "Less"; break;
      case DepthFunc::Always:    optionVal = "Always"; break;
      case DepthFunc::LessOrEqual:    optionVal = "LessOrEqual"; break;
      case DepthFunc::NotEqual:    optionVal = "NotEqual"; break;
      case DepthFunc::Equal:    optionVal = "Equal"; break;
      default: assert(false && "Invalid depthFunc"); break;
    }
    recordStringBasedProperty(wctx, "DepthFunc", CogsBin::PropertyValueType::Option, optionVal);
 
    recordStringBasedProperty(wctx, "DepthBiasEnabled", CogsBin::PropertyValueType::Option, options.depthBiasEnabled ? "true" : "false");
    propCount += 4;
    if (options.depthBiasEnabled) {
      recordStringBasedProperty(wctx, "DepthBiasConstant", CogsBin::PropertyValueType::Option, std::to_string(options.depthBias.constant));
      recordStringBasedProperty(wctx, "DepthBiasSlope", CogsBin::PropertyValueType::Option, std::to_string(options.depthBias.slope));
      recordStringBasedProperty(wctx, "DepthBiasClamp", CogsBin::PropertyValueType::Option, std::to_string(options.depthBias.clamp));
      propCount += 3;
    }
    return propCount;
  }
 
  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, CogsBin::PropertyValueType::Float, val);
          dstMatInst.propertyCount++;
        }
        break;
      case MaterialDataType::Float2:
        if (auto val = srcMatInst->getVec2Property(prop.key); val != prop.defaultVec2()) {
          recordProperty(wctx, prop.name, CogsBin::PropertyValueType::Float2, val);
          dstMatInst.propertyCount++;
        }
        break;
      case MaterialDataType::Float3:
        if (auto val = srcMatInst->getVec3Property(prop.key); val != prop.defaultVec3()) {
          recordProperty(wctx, prop.name, CogsBin::PropertyValueType::Float3, val);
          dstMatInst.propertyCount++;
        }
        break;
      case MaterialDataType::Float4:
        if (auto val = srcMatInst->getVec4Property(prop.key); val != prop.defaultVec4()) {
          recordProperty(wctx, prop.name, CogsBin::PropertyValueType::Float4, val);
          dstMatInst.propertyCount++;
        }
        break;
      case MaterialDataType::Bool:
        if (auto val = srcMatInst->getBoolProperty(prop.key); val != prop.defaultBool()) {
          recordProperty(wctx, prop.name, CogsBin::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, CogsBin::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 samplerIx = recordSamplerState(wctx, value.texture);
          uint32_t texIx = recordEmbeddedTexture(wctx, tex, samplerIx, sectionIx);
          recordProperty(wctx, prop.name, CogsBin::PropertyValueType::EmbeddedTexture, texIx);
          dstMatInst.propertyCount++;
        }
      }
    }
 
    else {
      for (uint32_t texI = 0; texI < srcMatInst->material->textureProperties.size(); texI++) {
        const TextureProperty& prop = srcMatInst->material->textureProperties[texI];
        auto 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;
            }
          }
          uint32_t pathIx = recordString(wctx, Cogs::IO::relativePath(source, dir));
          uint32_t samplerIx = recordSamplerState(wctx, value.texture);
          auto texIx = nextIndex(wctx.externalTextures);
          wctx.externalTextures.push_back({ pathIx, samplerIx });
          recordProperty(wctx, prop.name, CogsBin::PropertyValueType::ExternalTexture, texIx);
          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, CogsBin::PropertyValueType::Variant, variant.values[selector.value].key);
          dstMatInst.propertyCount++;
        }
        else {
          recordStringBasedProperty(wctx, variant.name, CogsBin::PropertyValueType::Variant, selector.value ? "true" : "false");
          dstMatInst.propertyCount++;
        }
      }
    }
 
    dstMatInst.propertyCount += recordMaterialOptions(wctx, srcMatInst->options);
 
    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(CogsBin::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(CogsBin::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 ? CogsBin::BoneFlags::HasOffset : CogsBin::BoneFlags::None) |
        (srcBone.used      ? CogsBin::BoneFlags::Used      : CogsBin::BoneFlags::None) |
        (srcBone.animated  ? CogsBin::BoneFlags::Animated  : CogsBin::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(CogsBin::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),
                                   CogsBin::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(CogsBin::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(CogsBin::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 = CogsBin::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(CogsBin::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 = (CogsBin::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, CogsBin::SectionType::META, 0);
 
    uint32_t subSections[size_t(CogsBin::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(CogsBin::SubSectionType::Buffers, wctx.buffers);
    REGISTER(CogsBin::SubSectionType::ExternalTextures, wctx.externalTextures);
    REGISTER(CogsBin::SubSectionType::EmbeddedTextures, wctx.embeddedTextures);
    REGISTER(CogsBin::SubSectionType::SamplerStates, wctx.samplerStates);
    REGISTER(CogsBin::SubSectionType::Strings, wctx.strings);
    REGISTER(CogsBin::SubSectionType::StringData, wctx.stringData);
    REGISTER(CogsBin::SubSectionType::Nodes, wctx.nodes);
    REGISTER(CogsBin::SubSectionType::Transforms, wctx.transforms);
    REGISTER(CogsBin::SubSectionType::BoundingBoxes, wctx.boundingBoxes);
    REGISTER(CogsBin::SubSectionType::MaterialInstances, wctx.materialInstances);
    REGISTER(CogsBin::SubSectionType::Properties, wctx.properties);
    REGISTER(CogsBin::SubSectionType::PropertyData, wctx.propertyData);
    REGISTER(CogsBin::SubSectionType::Meshes, wctx.meshes);
    REGISTER(CogsBin::SubSectionType::VertexStreams, wctx.vertexStreams);
    REGISTER(CogsBin::SubSectionType::VertexAttributes, wctx.vertexAttributes);
    REGISTER(CogsBin::SubSectionType::Bones, wctx.bones);
    REGISTER(CogsBin::SubSectionType::Skeletons, wctx.skeletons);
    REGISTER(CogsBin::SubSectionType::AnimTracks, wctx.animTracks);
    REGISTER(CogsBin::SubSectionType::AnimClips, wctx.animClips);
    REGISTER(CogsBin::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, CogsBin::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(CogsBin::SubSectionType::Buffers)], wctx.buffers);
    fillSubsection(metaSection, subSections[size_t(CogsBin::SubSectionType::ExternalTextures)], wctx.externalTextures);
    fillSubsection(metaSection, subSections[size_t(CogsBin::SubSectionType::EmbeddedTextures)], wctx.embeddedTextures);
    fillSubsection(metaSection, subSections[size_t(CogsBin::SubSectionType::SamplerStates)], wctx.samplerStates);
    fillSubsection(metaSection, subSections[size_t(CogsBin::SubSectionType::Strings)], wctx.strings);
    fillSubsection(metaSection, subSections[size_t(CogsBin::SubSectionType::StringData)], wctx.stringData);
    fillSubsection(metaSection, subSections[size_t(CogsBin::SubSectionType::Nodes)], wctx.nodes);
    fillSubsection(metaSection, subSections[size_t(CogsBin::SubSectionType::Transforms)], wctx.transforms);
    fillSubsection(metaSection, subSections[size_t(CogsBin::SubSectionType::BoundingBoxes)], wctx.boundingBoxes);
    fillSubsection(metaSection, subSections[size_t(CogsBin::SubSectionType::MaterialInstances)], wctx.materialInstances);
    fillSubsection(metaSection, subSections[size_t(CogsBin::SubSectionType::Properties)], wctx.properties);
    fillSubsection(metaSection, subSections[size_t(CogsBin::SubSectionType::PropertyData)], wctx.propertyData);
    fillSubsection(metaSection, subSections[size_t(CogsBin::SubSectionType::Meshes)], wctx.meshes);
    fillSubsection(metaSection, subSections[size_t(CogsBin::SubSectionType::VertexStreams)], wctx.vertexStreams);
    fillSubsection(metaSection, subSections[size_t(CogsBin::SubSectionType::VertexAttributes)], wctx.vertexAttributes);
    fillSubsection(metaSection, subSections[size_t(CogsBin::SubSectionType::Bones)], wctx.bones);
    fillSubsection(metaSection, subSections[size_t(CogsBin::SubSectionType::Skeletons)], wctx.skeletons);
    fillSubsection(metaSection, subSections[size_t(CogsBin::SubSectionType::AnimTracks)], wctx.animTracks);
    fillSubsection(metaSection, subSections[size_t(CogsBin::SubSectionType::AnimClips)], wctx.animClips);
    fillSubsection(metaSection, subSections[size_t(CogsBin::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 = CogsBin::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 = CogsBin::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 compressBlob(Context* /*context*/, WriteContext& wctx, Cogs::Memory::MemoryBuffer& compressed, const Cogs::Memory::MemoryBuffer& uncompressed)
  {
    int compressionLevel = ZSTD_CLEVEL_DEFAULT;
    if ((wctx.flags & WriteModelFlags::COMPRESS_MAX) != 0) {
      compressionLevel = ZSTD_maxCLevel();
    }
    else {
      compressionLevel = wctx.settings.compressionLevel;
    }
 
    ZSTD_CCtx* zstd_ctx = ZSTD_createCCtx();
    if (zstd_ctx == nullptr) {
      LOG_ERROR(logger, "Failed to create zstd context.");
      return false;
    }
 
    size_t maxSize = ZSTD_compressBound(uncompressed.size());
    compressed.resize(maxSize, false);
 
    size_t result = ZSTD_compressCCtx(zstd_ctx, compressed.data(), maxSize, uncompressed.data(), uncompressed.size(), compressionLevel);
    if (ZSTD_isError(result)) {
      ZSTD_freeCCtx(zstd_ctx);
      LOG_ERROR(logger, "zstd compression failed: %s", ZSTD_getErrorName(result));
      return false;
    }
    else if (uncompressed.size() <= result) {
      //LOG_DEBUG(logger, "compressed size is greater or equal to uncompressed size.");
    }
 
    compressed.resize(result);
    ZSTD_freeCCtx(zstd_ctx);
    return true;
  }
 
  bool write(Context* context, WriteContext& wctx)
  {
    pack(context, wctx);
 
    compressSections(context, wctx);
 
    // layout file and populate header
    uint64_t uncompressedSize = sizeof(CogsBin::Header) + sizeof(CogsBin::SectionInfo)*wctx.sectionInfos.size();
 
    CogsBin::Header header{ };
    header.magic = CogsBin::HeaderMagic;
    header.version = CogsBin::Version;
    header.fileLength = sizeof(CogsBin::Header) + sizeof(CogsBin::SectionInfo) * wctx.sectionInfos.size();
    header.sectionCount = nextIndex(wctx.sectionInfos);
    for (auto & info : wctx.sectionInfos) {
      if (info.compression == CogsBin::Compression::None) {
        // if no compression, align
        header.fileLength = (header.fileLength + (CogsBin::CogsSectionAlignment - 1)) & ~(CogsBin::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;
    }
 
    if ((wctx.flags & WriteModelFlags::COMPRESS_ZSTD_AS_FILE) != 0) {
 
      // Pack everything into a single buffer
      Cogs::Memory::MemoryBuffer uncompressed;
      uncompressed.write(&header, sizeof(CogsBin::Header));
      uncompressed.write(wctx.sectionInfos.data(), sizeof(CogsBin::SectionInfo) * header.sectionCount);
      for (size_t i = 0; i < header.sectionCount; i++) {
        const CogsBin::SectionInfo& info = wctx.sectionInfos[i];
        const ::WSection& section = *wctx.sections[i].get();
        assert(uncompressed.pos() <= info.fileOffset);
        while (uncompressed.pos() < info.fileOffset) {
          uncompressed.write8(0); // Padding
        }
        uncompressed.write(section.contents.data(), info.fileSize);
      }
      assert(uncompressedSize == uncompressed.pos());
 
      Cogs::Memory::MemoryBuffer compressed;
      if (!compressBlob(context, wctx, compressed, uncompressed)) {
        return false;
      }
 
      size_t r = fwrite(compressed.data(), compressed.size(), 1, file);
      if (r != 1) {
        fclose(file);
        LOG_ERROR(logger, "Error writing to %s", wctx.fileName.c_str());
        return false;
      }
    }
    else {
      // write header
      auto r = fwrite(&header, sizeof(CogsBin::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(CogsBin::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
    if ((wctx.flags & WriteModelFlags::COMPRESS_ZSTD_AS_FILE) == 0) {
      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::writeModel(Context * context, uint32_t & numVertes, uint32_t & numIndexes, const StringView & fileName, const Model * model, WriteModelSettings * settings)
{
  auto flags = settings->flags;
 
  if (!model) return false;
 
  if (context->variables->get("cogsbin.writeVersion", 3) == 3) {
    return writeCogsBin3Model(context, numVertes, numIndexes, fileName, model, settings);
  }
  else {
    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::writeModels(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;
 
  if (context->variables->get("cogsbin.writeVersion", 3) == 3) {
    return writeCogsBin3Models(context, numVertes, numIndexes, fileName, entity, N, flags);
  }
  else {
    uint16_t section = 0;
    WriteContext wctx{};
    wctx.fileName = fileName.to_string();;
    wctx.flags = WriteModelFlags(flags);
    wctx.currentAnimation = nullptr;
    wctx.models.emplace_back(CogsBin::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;
}
 
bool Cogs::Core::writeModel(Context * context, const StringView & fileName, ComponentModel::Entity * entity, WriteModelFlags flags)
{
  uint32_t numVertes;
  uint32_t numIndexes;
  return writeModels(context, numVertes, numIndexes, fileName, &entity, 1, flags);
}
 
bool Cogs::Core::writeModel(Context * context, uint32_t& numVertes, uint32_t& numIndexes, const StringView & fileName, ComponentModel::Entity * entity, WriteModelFlags flags)
{
  return writeModels(context, numVertes, numIndexes, fileName, &entity, 1, flags);
}
 
 
#if defined(_WIN32) && defined(MAKE_DEBUGABLE)
#pragma optimize( "", on )
#endif
 
#else
// Emscripten
 
bool Cogs::Core::writeModel(Context * /*context*/, uint32_t & /*numVertes*/, uint32_t & /*numIndexes*/, const StringView & /*fileName*/, const Model * /*model*/, WriteModelSettings * /*settings*/)
{
  return false;
}
 
bool Cogs::Core::writeModels(Context * /*context*/, uint32_t& /*numVertes*/, uint32_t& /*numIndexes*/, const StringView & /*fileName*/, ComponentModel::Entity ** /*entity*/, size_t /*N*/, WriteModelFlags /*flags*/)
{
  return false;
}
 
bool Cogs::Core::writeModel(Context * /*context*/, const StringView & /*fileName*/, ComponentModel::Entity * /*entity*/, WriteModelFlags /*flags*/)
{
  return false;
}
 
bool Cogs::Core::writeModel(Context * /*context*/, uint32_t& /*numVertes*/, uint32_t& /*numIndexes*/, const StringView & /*fileName*/, ComponentModel::Entity * /*entity*/, WriteModelFlags /*flags*/)
{
  return false;
}
 
#endif