AssetWriter.cpp

#include "AssetWriter.h"
 
#ifdef _WIN32
#pragma warning(push)
#pragma warning(disable:4996)
#endif
#include "rapidjson/document.h"
#ifdef _WIN32
#pragma warning(pop)
#endif
 
#include <cstdio> // fopen etc
#include "zstd.h"
#include "rapidjson/stringbuffer.h"
#include "rapidjson/filewritestream.h"
#include "rapidjson/prettywriter.h"
#include "rapidjson/error/en.h"
 
#include "Foundation/Logging/Logger.h"
 
#include "Context.h"
#include "Engine.h"
#include "EntityStore.h"
#include "EntityDefinition.h"
 
#include "Editor/IEditor.h"
 
#include "Components/Core/AssetComponent.h"
#include "Components/Core/TransformComponent.h"
 
#include "Resources/Asset.h"
#include "Resources/ResourceBase.h"
#include "Resources/Texture.h"
#include "Resources/MaterialInstance.h"
 
#include "Services/Variables.h"
 
#include "JsonMemoryBufferStream.h"
 
#include "EntityWriter.h"
#include <span>
 
using namespace rapidjson;
 
using namespace Cogs::Reflection;
 
#ifndef EMSCRIPTEN
 
namespace
{
  using namespace Cogs::Core;
 
  const Cogs::Logging::Log logger = Cogs::Logging::getLogger("AssetWriter");
 
  constexpr uint32_t NoValue = static_cast<uint32_t>(-1);
  const Cogs::Core::StringRef idsString = Cogs::Core::Strings::add("ids");
  const Cogs::Core::StringRef bboxString = Cogs::Core::Strings::add("bbox");
  const Cogs::Core::StringRef errorsString = Cogs::Core::Strings::add("errors");
  const Cogs::Core::StringRef byteSizeString = Cogs::Core::Strings::add("byteSize");
 
  const char* currentErrnoString()
  {
    static char buff[256] = "unknown";
  #ifdef _WIN32
    strerror_s(buff, sizeof(buff), errno);
  #else
    strerror_r(errno, buff, sizeof(buff));
  #endif
    return buff;
  }
 
  struct WriterCtx
  {
    Context* context = nullptr;
    MemoryPoolAllocator<CrtAllocator> alloc;
    AssetWriteFlags writeFlags = AssetWriteFlags::None;
 
  public:
    [[nodiscard]] Value encodeString(const std::string& str)
    {
      return Value(str.data(), uint32_t(str.length()), alloc);
    }
 
    [[nodiscard]] Value encodeString(const Cogs::StringView& view)
    {
      return Value(view.data(), uint32_t(view.length()), alloc);
    }
 
    template<class ValueType>
    [[nodiscard]] Value encodeSpan(std::span<ValueType> values)
    {
      Value vec(kArrayType);
      for (size_t i = 0; i < values.size(); i++) {
        vec.PushBack(values[i], alloc);
      }
      return vec;
    }
  };
 
  [[nodiscard]] Value getStringProperty(WriterCtx& ctx, const AssetDefinition& definition, const PropertyInfo& propertyInfo)
  {
    Cogs::StringView string = definition.scene.properties.getString(propertyInfo);
    return ctx.encodeString(string);
  }
 
  [[nodiscard]] bool writeDoc(WriterCtx& ctx, Value& entities, Value& resources, const char* path)
  {
    Document doc(&ctx.alloc);
    doc.SetObject();
 
    if (resources.MemberCount()) {
      doc.AddMember("resources", resources, ctx.alloc);
    }
 
    if (!entities.Empty()) {
      doc.AddMember("entities", entities, ctx.alloc);
    }
 
    Cogs::IO::createDirectories(path);
    Cogs::Memory::MemoryBuffer buffer;
 
    if ((ctx.writeFlags & AssetWriteFlags::PrettyPrint) == AssetWriteFlags::PrettyPrint) {
      JsonMemoryBufferStream stream(buffer);
      PrettyWriter<JsonMemoryBufferStream> writer(stream);
      writer.SetIndent(' ', 2);
      writer.SetMaxDecimalPlaces(4);
      doc.Accept(writer);
    }
    else {
      JsonMemoryBufferStream stream(buffer);
      Writer<JsonMemoryBufferStream> writer(stream);
      writer.SetMaxDecimalPlaces(4);
      doc.Accept(writer);
    }
 
    if ((ctx.writeFlags & AssetWriteFlags::Compress) == AssetWriteFlags::Compress) {
      int compressionLevel = ctx.context->variables->get("resources.compressionLevel", 0);
      size_t uncompressedSize = buffer.size();
      size_t maxSize = ZSTD_compressBound(uncompressedSize);
      Cogs::Memory::MemoryBuffer compressed(maxSize);
 
      ZSTD_CCtx* zstd_ctx = ZSTD_createCCtx();
      size_t result = ZSTD_compressCCtx(zstd_ctx, compressed.data(), maxSize, buffer.data(), uncompressedSize,compressionLevel);
      if (ZSTD_isError(result)) {
        LOG_ERROR(logger, "%s: zstd compression failed: %s", path, ZSTD_getErrorName(result));
        return false;
      }
      else if (uncompressedSize <= result) {
        LOG_WARNING(logger, "%s: compressed size greater or equal to uncompressed size", path);
      }
      else {
        compressed.resize(result);
        buffer.swap(compressed);
      }
      ZSTD_freeCCtx(zstd_ctx);
    }
 
    FILE* file = std::fopen(path, "wb");
    if (!file) {
      LOG_ERROR(logger, "Failed to open '%s' for writing: %s", path, currentErrnoString());
      return false;
    }
    size_t n = fwrite(buffer.data(), 1, buffer.size(), file);
    fclose(file);
    if (n != buffer.size()) {
      LOG_ERROR(logger, "Error writing to %s, wrote %zu of %zu: %s", path, n, buffer.size(), currentErrnoString());
      return false;
    }
    return true;
  }
 
  [[nodiscard]] bool writeEntityItem(WriterCtx& ctx, Value& entity, const AssetDefinition& definition, size_t entityIx);
 
  [[nodiscard]] bool writeBBoxProperty(WriterCtx& ctx, Value& entityPoperties, const PropertyRange& propertyRange, const char* what, bool required)
  {
    if (uint32_t ix = propertyRange.getPropertyIndex(bboxString); ix != PropertyStore::NoProperty) {
      std::span<const float> bboxValues = propertyRange.store->getFloatArray(ix);
      if (bboxValues.size() == 6) {
        Value bboxValue(kArrayType);
        for (size_t k = 0; k < 6; k++) { bboxValue.PushBack(Value(bboxValues[k]), ctx.alloc); }
        entityPoperties.AddMember("bbox", bboxValue, ctx.alloc);
        return true;
      }
      LOG_ERROR(logger, "%s item bounding box has wrong number of elements (%zu != 6)", what, bboxValues.size());
      return false;
    }
    else if (!required) {
      return true;
    }
    LOG_ERROR(logger, "%s item is missing bounding box property", what);
    return false;
  }
 
  [[nodiscard]] bool writeLodGroupItem(WriterCtx& ctx, Value& entity, Value& entityPoperties, const AssetDefinition& definition, size_t entityIx)
  {
    const SceneEntityDefinition& entityDef = definition.scene.entities[entityIx];
    PropertyRange propertyRange = definition.scene.getProperties(entityDef);
 
    entity.AddMember("type", "LodGroup", ctx.alloc);
 
    if (std::span<const uint32_t> ids = propertyRange.getProperty(idsString, std::span<const uint32_t>()); !ids.empty()) {
      Value idsValue(kArrayType);
      for (const uint32_t id : ids) {
        idsValue.PushBack(id, ctx.alloc);
      }
      entityPoperties.AddMember("ids", idsValue, ctx.alloc);
    }
 
    if (!writeBBoxProperty(ctx, entityPoperties, propertyRange, "LodGroup", true)) {
      return false;
    }
 
    if (entityDef.lod.numLods) {
 
      std::span<const float> errorValues = propertyRange.getProperty(errorsString, std::span<const float>());
      if (errorValues.size() == entityDef.lod.numLods) {
        Value value(kArrayType);
        for (size_t k = 0; k < errorValues.size(); k++) { value.PushBack(Value(errorValues[k]), ctx.alloc); }
        entityPoperties.AddMember("errors", value, ctx.alloc);
      }
      else {
        LOG_ERROR(logger, "Lod level item count (=%u) does not match number of error values (=%zu)", entityDef.lod.numLods, errorValues.size());
        return false;
      }
 
      Value lods(kArrayType);
 
      uint32_t childIx = entityDef.firstChild;
      for (size_t k = 0; k < entityDef.lod.numLods; k++) {
 
        // No entities at this level, store as empty object
        if (childIx == ::NoValue) {
          lods.PushBack(Value(kObjectType), ctx.alloc);
        }
 
        else {
 
          // Sanity check
          if (definition.scene.entities.size() <= childIx) {
            LOG_ERROR(logger, "Illegal entity first child %u", childIx);
            return false;
          }
 
          // Single entity at this level (nextLodSibling tie together siblings within a lod level)
          if (definition.scene[childIx].nextLodSibling == ::NoValue) {
            Value child(kObjectType);
            if (!writeEntityItem(ctx, child, definition, childIx)) return false;
            lods.PushBack(child, ctx.alloc);
          }
 
          // Multiple entities at this level, group them into an array
          else {
            Value children(kArrayType);
            while (true) {
 
              Value child(kObjectType);
              if (!writeEntityItem(ctx, child, definition, childIx)) return false;
              children.PushBack(child, ctx.alloc);
 
              if (definition.scene[childIx].nextLodSibling == ::NoValue) break;
              childIx = definition.scene[childIx].nextLodSibling;
            }
 
            lods.PushBack(children, ctx.alloc);
          }
 
          childIx = definition.scene[childIx].nextSibling;
        }
      }
      entity.AddMember("lods", lods, ctx.alloc);
    }
    return true;
  }
 
  [[nodiscard]] bool writeModelItem(WriterCtx& ctx, Value& entity, Value& entityPoperties, const AssetDefinition& definition, size_t entityIx)
  {
    const SceneEntityDefinition& entityDef = definition.scene.entities[entityIx];
    if (entityDef.model.index == ::NoValue) {
      LOG_ERROR(logger, "Model without unset source");
      return false;
    }
 
    PropertyRange propertyRange = definition.scene.getProperties(entityDef);
    if (propertyRange.numProperties) {
      if(!writeBBoxProperty(ctx, entityPoperties, propertyRange, "Model", false)) {
        return false;
      }
    }
 
 
    Value path;
    const PropertyInfo& pathInfo = definition.scene.properties.getPropertyByIndex(entityDef.model.index);
    switch (pathInfo.type) {
    case PropertyType::UnsignedInteger:
      path.SetUint(pathInfo.uintValue);
      break;
    case PropertyType::String:
      path = getStringProperty(ctx, definition, pathInfo);
      break;
    default:
      LOG_ERROR(logger, "Model source is neither uint nor string");
      return false;
    }
 
    // No part, we can just store the model as a string
    if (entityDef.model.part == ::NoValue) {
      entity.AddMember("model", path, ctx.alloc);
    }
 
    // We have a part, create an object with source and part
    else {
      Value modelRef(kObjectType);
      modelRef.AddMember("source", path, ctx.alloc);
      if (entityDef.model.part != ::NoValue) {
        modelRef.AddMember("part", entityDef.model.part, ctx.alloc);
      }
      entity.AddMember("model", modelRef, ctx.alloc);
    }
 
    return true;
  }
 
  [[nodiscard]] bool writeAssetItem(WriterCtx& ctx, Value& entity, Value& /*entityPoperties*/, const AssetDefinition& definition, size_t entityIx)
  {
    const SceneEntityDefinition& entityDef = definition.scene.entities[entityIx];
 
    if (entityDef.asset.index == ::NoValue) {
      LOG_ERROR(logger, "Asset without source");
      return false;
    }
    Value sourceValue;
    const PropertyInfo& sourceInfo = definition.scene.properties.getPropertyByIndex(entityDef.asset.index);
    switch (sourceInfo.type) {
    case PropertyType::UnsignedInteger:
      sourceValue.SetUint(sourceInfo.uintValue);
      break;
    case PropertyType::String: {
      sourceValue = getStringProperty(ctx, definition, sourceInfo);
      break;
    }
    default:
      LOG_ERROR(logger, "Source property is neither uint nor string");
      return false;
    }
 
    // If we only have a source, we can store it as string
    if (entityDef.asset.flags == 0 && entityDef.asset.material == ::NoValue) {
      entity.AddMember("asset", sourceValue, ctx.alloc);
      return true;
    }
 
    // Create object
    Value assetValue(kObjectType);
    if (entityDef.asset.flags != 0) {
      std::string flagsString;
      AssetFlags flags = AssetFlags(entityDef.asset.flags);
      if ((flags & AssetFlags::InstantiateOnDemand) == AssetFlags::InstantiateOnDemand) {
        flagsString.append("InstantiateOnDemand | ");
        flags &= ~AssetFlags::InstantiateOnDemand;
      }
      if ((flags & AssetFlags::RelativePaths) == AssetFlags::RelativePaths) {
        flagsString.append("RelativePaths | ");
        flags &= ~AssetFlags::RelativePaths;
      }
      if ((flags & AssetFlags::OverrideMaterial) == AssetFlags::OverrideMaterial) {
        flagsString.append("OverrideMaterial | ");
        flags &= ~AssetFlags::OverrideMaterial;
      }
      if (flags != AssetFlags::None) {
        LOG_ERROR(logger, "Unhandled asset flags");
        return false;
      }
 
      assert(3 < flagsString.length()); // Trim last pipe
      const Cogs::StringView writeFlagsString(flagsString.c_str(), flagsString.size() - 3);
      assetValue.AddMember("flags",  ctx.encodeString(writeFlagsString), ctx.alloc);
    }
 
    assetValue.AddMember("source", sourceValue, ctx.alloc);
 
    if (entityDef.asset.material != ::NoValue) {
      const PropertyInfo& materialInfo = definition.scene.properties.getPropertyByIndex(entityDef.asset.material);
      if (materialInfo.type != PropertyType::String) {
        LOG_ERROR(logger, "Material property type isn't a string");
        return false;
      }
      assetValue.AddMember("material", getStringProperty(ctx, definition, materialInfo), ctx.alloc);
    }
 
    entity.AddMember("asset", assetValue, ctx.alloc);
    return true;
  }
 
  [[nodiscard]] Value encodeFieldValue(WriterCtx& ctx, const FieldValue& fieldValue)
  {
    switch (fieldValue.type) {
    case DefaultValueType::Bool:             return Value(fieldValue.boolValue);
    case DefaultValueType::Float:            return Value(double(fieldValue.floatValue));
    case DefaultValueType::Int:              return Value(fieldValue.intValue);
    case DefaultValueType::Enum:             return Value(fieldValue.intValue);
    case DefaultValueType::Vec2:             return ctx.encodeSpan(std::span<const float>(glm::value_ptr(fieldValue.float2), 2));
    case DefaultValueType::Vec3:             return ctx.encodeSpan(std::span<const float>(glm::value_ptr(fieldValue.float3), 3));
    case DefaultValueType::Vec4:             return ctx.encodeSpan(std::span<const float>(glm::value_ptr(fieldValue.float4), 4));
    case DefaultValueType::Mat4:             return ctx.encodeSpan(std::span<const float>(glm::value_ptr(fieldValue.mat4), 16));
    case DefaultValueType::DVec2:            return ctx.encodeSpan(std::span<const double>(glm::value_ptr(fieldValue.double2), 2));
    case DefaultValueType::DVec3:            return ctx.encodeSpan(std::span<const double>(glm::value_ptr(fieldValue.double3), 3));
    case DefaultValueType::DVec4:            return ctx.encodeSpan(std::span<const double>(glm::value_ptr(fieldValue.double4), 4));
    case DefaultValueType::Quaternion:       return ctx.encodeSpan(std::span<const float>(glm::value_ptr(fieldValue.quat), 4));
    case DefaultValueType::String:
    case DefaultValueType::Model:
    case DefaultValueType::Asset:
    case DefaultValueType::Texture:
    case DefaultValueType::Gui:              return ctx.encodeString(fieldValue.value);
    case DefaultValueType::MaterialInstance: {
      const MaterialInstanceDefinition* matDef = fieldValue.asMaterialInstance();
      if (matDef && !matDef->reference.empty()) {
        return ctx.encodeString(std::string("$") + matDef->reference);
      }
      break;
    }
    case DefaultValueType::Unknown:
    case DefaultValueType::Mesh:
    case DefaultValueType::MultiString:
    case DefaultValueType::IntArray:
    case DefaultValueType::FloatArray:
    case DefaultValueType::Vec2Array:
    case DefaultValueType::Vec3Array:
    case DefaultValueType::Vec4Array:
    case DefaultValueType::Entity:
    case DefaultValueType::EntityArray:
    case DefaultValueType::Extension:
      LOG_ERROR(logger, "Unhandled value type %u", uint32_t(fieldValue.type));
      break;
    default:
      assert(false && "Illegal enum value");
    }
    return Value();
  }
 
  [[nodiscard]] bool writeEntityItem(WriterCtx& ctx, Value& entity, const AssetDefinition& definition, size_t entityIx)
  {
    const SceneEntityDefinition& entityDef = definition.scene.entities[entityIx];
    PropertyRange propertyRange = definition.scene.getProperties(entityDef);
 
    if ((ctx.writeFlags & AssetWriteFlags::Strip) != AssetWriteFlags::Strip) {
      if (entityDef.nameIndex != ::NoValue) {
        Cogs::StringView name = definition.scene.properties.getString(definition.scene.properties.getPropertyByIndex(entityDef.nameIndex));
        if (!name.empty()) {
          entity.AddMember("name", ctx.encodeString(name), ctx.alloc);
        }
      }
    }
 
    Value entityPoperties(kObjectType);
    if (entityDef.isLodGroup()) {
      if (!writeLodGroupItem(ctx, entity, entityPoperties, definition, entityIx)) return false;
    }
    else if (entityDef.isModel()) {
      if (!writeModelItem(ctx, entity, entityPoperties, definition, entityIx)) return false;
    }
    else if (entityDef.isAsset()) {
      if (!writeAssetItem(ctx, entity, entityPoperties, definition, entityIx)) return false;
    }
    else if(!entityDef.isEmpty()) {
 
      const Cogs::StringView entityType = Strings::get(entityDef.type);
      if (!entityType.empty()) {
        entity.AddMember("type", ctx.encodeString(entityType), ctx.alloc);
      }
      else {
        LOG_WARNING(logger, "Entity without type");
      }
 
 
      if (entityDef.numFields) {
        for (const FieldValue& entry : std::span(definition.scene.fieldValues).subspan(entityDef.firstField, entityDef.numFields)) {
 
          if (entry.componentId == Cogs::Reflection::NoType) {
            LOG_WARNING(logger, "Missing field component type, ignoring");
            continue;
          }
 
          if(entry.fieldId == Cogs::Reflection::NoField) {
            LOG_WARNING(logger, "Missing field id, ignoring");
            continue;
          }
 
          const Cogs::Reflection::Type& componentType = Cogs::Reflection::TypeDatabase::getType(entry.componentId);
          const Cogs::Reflection::Field* field = componentType.getField(entry.fieldId);
          if (!field) {
            LOG_ERROR(logger, "Field %u not found on type %s.", uint32_t(entry.fieldId), componentType.getName().c_str());
            continue;
          }
 
          std::string key;
          key.append(componentType.getName().c_str());
          key.append(1, '.');
          key.append(field->getName().c_str());
          Value keyValue = ctx.encodeString(key);
 
          entity.AddMember(keyValue, encodeFieldValue(ctx, entry), ctx.alloc);
        }
      }
 
      if (entityDef.numProperties) {
        for (uint32_t i = 0; i < entityDef.numProperties; i++) {
          const PropertyInfo& propInfo = definition.scene.properties.getPropertyByIndex(entityDef.firstProperty + i);
 
          Value keyValue = ctx.encodeString(Strings::get(propInfo.key));
 
          switch (propInfo.type) {
          case PropertyType::Unknown:
            LOG_ERROR(logger, "Unhandled property type %u", uint32_t(propInfo.type));
            break;
          case PropertyType::Bool:
            entityPoperties.AddMember(keyValue, propInfo.boolValue, ctx.alloc);
            break;
          case PropertyType::Integer:
            entityPoperties.AddMember(keyValue, propInfo.intValue, ctx.alloc);
            break;
          case PropertyType::Int2:
            entityPoperties.AddMember(keyValue, ctx.encodeSpan(std::span<const int32_t>(propInfo.int2Value, 2)), ctx.alloc);
            break;
          case PropertyType::UnsignedInteger:
            entityPoperties.AddMember(keyValue, propInfo.uintValue, ctx.alloc);
            break;
          case PropertyType::UInt2:
            entityPoperties.AddMember(keyValue, ctx.encodeSpan(std::span<const uint32_t>(propInfo.uint2Value, 2)), ctx.alloc);
            break;
          case PropertyType::Float:
            entityPoperties.AddMember(keyValue, propInfo.floatValue, ctx.alloc);
            break;
          case PropertyType::Float2:
            entityPoperties.AddMember(keyValue, ctx.encodeSpan(std::span<const float>(propInfo.float2Value, 2)), ctx.alloc);
            break;
          case PropertyType::Double:
            entityPoperties.AddMember(keyValue, propInfo.doubleValue, ctx.alloc);
            break;
          case PropertyType::StringRef:
            entityPoperties.AddMember(keyValue, ctx.encodeString(Strings::get(propInfo.stringRefValue)), ctx.alloc);
            break;
          case PropertyType::String:
            entityPoperties.AddMember(keyValue, ctx.encodeString(definition.scene.properties.getString(propInfo)), ctx.alloc);
            break;
          case PropertyType::FloatArray:
            entityPoperties.AddMember(keyValue, ctx.encodeSpan(definition.scene.properties.getFloatArray(propInfo)), ctx.alloc);
            break;
          case PropertyType::IntArray:
            entityPoperties.AddMember(keyValue, ctx.encodeSpan(definition.scene.properties.getIntArray(propInfo)), ctx.alloc);
            break;
          case PropertyType::UIntArray:
            entityPoperties.AddMember(keyValue, ctx.encodeSpan(definition.scene.properties.getUIntArray(propInfo)), ctx.alloc);
            break;
          case PropertyType::DoubleArray:
            entityPoperties.AddMember(keyValue, ctx.encodeSpan(definition.scene.properties.getDoubleArray(propInfo)), ctx.alloc);
            break;
          default:
            assert(false && "Illegal enum value");
            return false;
          }
        }
      }
    }
 
    if (entityPoperties.MemberCount()) {
      entity.AddMember("properties", entityPoperties, ctx.alloc);
    }
    return true;
  }
 
}
 
 
bool Cogs::Core::writeAsset(Context * context, StringView fileName, AssetWriteFlags flags, ComponentModel::Entity * root)
{
  std::string saveFileName(fileName);
  if (!root) {
    auto file = fopen(saveFileName.c_str(), "w");
    if (file == nullptr) {
      LOG_ERROR(logger, "Failed to open output file: %s", saveFileName.c_str());
      return false;
    }
 
    std::vector<char> buffer(16384);
 
    FileWriteStream stream(file, buffer.data(), buffer.size());
    PrettyWriter<FileWriteStream> out(stream);
 
    WriterCtx ctx;
    ctx.context = context;
    ctx.writeFlags = flags;
 
    Document d;
    auto & a = d.GetAllocator();
    d.SetObject();
 
    {
      Value metaValue(kObjectType);
 
      metaValue.AddMember("flags", "true", a);
 
      d.AddMember("meta", metaValue, a);
    }
 
    {
      Value resourcesValue(kObjectType);
      Value entitiesValue(kArrayType);
 
      auto store = context->store;
      auto & entities = store->getEntities();
 
      SerializationContext sc;
 
      for (auto & e : entities) {
        auto entity = e.second;
 
        if (entity) {
          auto transformComponent = entity->getComponent<TransformComponent>();
 
          if (transformComponent && transformComponent->parent) continue;
 
          Value entityValue(kObjectType);
 
          writeEntity(context, entity.get(), entityValue, d, &sc, flags);
 
          entitiesValue.PushBack(entityValue, a);
        }
      }
 
      for (auto& r : sc.assets) {
        Value resourceValue(kObjectType);
        resourceValue.AddMember("type", "Asset", a);
        resourceValue.AddMember("source", ctx.encodeString(r->getSource()), a);
 
        resourcesValue.AddMember(ctx.encodeString(r->getName()), resourceValue, a);
      }
 
      for (auto & r : sc.models) {
        Value resourceValue(kObjectType);
        resourceValue.AddMember("type", "Model", a);
        resourceValue.AddMember("source", ctx.encodeString(r->getSource()), a);
 
        resourcesValue.AddMember(ctx.encodeString(r->getName()), resourceValue, a);
      }
 
      Value materialInstances(kObjectType);
 
      for (auto & r : sc.materialInstances) {
        auto instance = (MaterialInstance *)r.get();
        auto material = instance->material;
 
        Value resourceValue(kObjectType);
        resourceValue.AddMember("type", "MaterialInstance", a);
        resourceValue.AddMember("material", ctx.encodeString(material->getName()), a);
        resourceValue.AddMember("permutation", ctx.encodeString(material->permutationKeys[instance->permutationIndex]), a);
 
        for (auto & tProp : material->textureProperties) {
          auto instanceValue = instance->getTextureProperty(tProp.key);
          if (HandleIsValid(instanceValue.texture.handle) && instanceValue.texture.handle != tProp.texture.handle) {
            auto texName = instanceValue.texture.handle->getName();
            texName = "$" + texName.to_string();
 
            resourceValue.AddMember(ctx.encodeString(tProp.name), ctx.encodeString(texName), a);
 
            sc.textures.insert(instanceValue.texture.handle);
          }
        }
 
        for (auto & prop : material->constantBuffers.variables) {
          switch (prop.type) {
          case MaterialDataType::Float:
          {
            auto instanceValue = instance->getFloatProperty(prop.key);
 
            if (instanceValue != prop.defaultFloat()) {
              resourceValue.AddMember(ctx.encodeString(prop.name), Value((double)instanceValue), a);
            }
 
            break;
          }
          case MaterialDataType::Float4:
          {
            auto instanceValue = instance->getVec4Property(prop.key);
 
            if (instanceValue != prop.defaultVec4()) {
              Value v;
              v.SetArray();
 
              for (int i = 0; i < 4; ++i) {
                v.PushBack(instanceValue[i], a);
              }
 
              resourceValue.AddMember(ctx.encodeString(prop.name), v, a);
            }
 
            break;
          }
          case MaterialDataType::Float3:
          {
            auto instanceValue = instance->getVec3Property(prop.key);
 
            if (instanceValue != prop.defaultVec3()) {
              Value v;
              v.SetArray();
 
              for (int i = 0; i < 3; ++i) {
                v.PushBack(instanceValue[i], a);
              }
 
              resourceValue.AddMember(ctx.encodeString(prop.name), v, a);
            }
 
            break;
          }
          case MaterialDataType::Float2:
          {
            auto instanceValue = instance->getVec2Property(prop.key);
 
            if (instanceValue != prop.defaultVec2()) {
              Value v;
              v.SetArray();
 
              for (int i = 0; i < 2; ++i) {
                v.PushBack(instanceValue[i], a);
              }
 
              resourceValue.AddMember(ctx.encodeString(prop.name), v, a);
            }
 
            break;
          }
          case MaterialDataType::UInt:
          {
            uint32_t instanceValue = instance->getProperty<uint32_t>(prop.key);
            if (instanceValue != prop.defaultUInt()) {
              resourceValue.AddMember(ctx.encodeString(prop.name), Value(instanceValue), a);
            }
 
            break;
          }
          case MaterialDataType::Bool:
          {
            bool instanceValue = instance->getProperty<bool>(prop.key);
            if (instanceValue != prop.defaultBool()) {
              resourceValue.AddMember(ctx.encodeString(prop.name), Value(instanceValue ? "true" : "false", a), a);
            }
 
            break;
          }
          default:
            LOG_WARNING(logger, "Skipped serialization of unsupported material property %s. Typeid:%s", prop.name.c_str(), Cogs::Core::DataTypeNames[int(prop.type)]);
            break;
          }
        }
 
        Value variantsValue(kObjectType);
 
        const ShaderVariants& variants = material->definition.variants;
        for (const ShaderVariantSelector& selector : instance->variantSelectors) {
 
          const ShaderVariantDefinition& variant = variants[selector.index];
          if (variant.isShared) continue; // Do not store shared variants.
 
          if (selector.value != variant.defaultValue) {
            switch (variant.type)
            {
            case ShaderVariantType::Bool:
            {
              Value b;
              b.SetBool(selector.value != 0);
 
              variantsValue.AddMember(ctx.encodeString(variant.name), b, a);
            }
            break;
            case ShaderVariantType::Enum:
            {
              Value b;
              b.SetString(variant.values[selector.value].key.c_str(), a);
 
              variantsValue.AddMember(ctx.encodeString(variant.name), b, a);
            }
            break;
            case ShaderVariantType::Int:
            {
              Value i;
              i.SetInt((int)selector.value);
 
              variantsValue.AddMember(ctx.encodeString(variant.name), i, a);
            }
            break;
            default:
              LOG_WARNING(logger, "Skipped serialization of unsupported material variant %s", variant.name.c_str());
              break;
            }
          }
        }
 
        if (variantsValue.MemberCount()) {
          resourceValue.AddMember("variants", variantsValue, a);
        }
 
        materialInstances.AddMember(ctx.encodeString(r->getName()), resourceValue, a);
      }
 
      for (auto & r : sc.textures) {
        auto texture = (Texture *)r.get();
 
        Value resourceValue(kObjectType);
        resourceValue.AddMember("type", "Texture", a);
        resourceValue.AddMember("source", ctx.encodeString(r->getSource()), a);
 
        if (texture->description.format != TextureFormat::R8G8B8A8_UNORM_SRGB) {
          resourceValue.AddMember("flags", "LinearColorSpace", a);
        }
 
        resourcesValue.AddMember(ctx.encodeString(r->getName()), resourceValue, a);
      }
 
      for (auto & m : materialInstances.GetObject()) {
        resourcesValue.AddMember(m.name, m.value, a);
      }
 
      if (resourcesValue.MemberCount()) {
        d.AddMember("resources", resourcesValue, a);
      }
 
      d.AddMember("entities", entitiesValue, a);
    }
 
    bool ok = d.Accept(out);
    if (!ok) {
      LOG_ERROR(logger, "JSon serialization failed.");
    }
 
    stream.Flush();
 
    fclose(file);
    return ok;
  }
 
  LOG_ERROR(logger, "Write specific entity not supported (only null allowed).");
  return false;
}
 
bool Cogs::Core::writeAsset(class Context* context, const char* path, AssetHandle assetHandle, AssetWriteFlags writeFlags)
{
  if (!HandleIsValid(assetHandle)) {
    LOG_ERROR(logger, "Undefined asset");
    return false;
  }
  Asset* asset = assetHandle.resolve();
 
  if (!asset->isLoaded()) {
    LOG_ERROR(logger, "Asset is not loaded");
    return false;
  }
  const AssetDefinition& definition = asset->definition;
 
  WriterCtx ctx;
  ctx.context = context;
  ctx.writeFlags = writeFlags;
 
  Value resources(kObjectType);
  for (const ResourceDefinition& resDef : definition.resources) {
 
    if (resDef.name.empty()) {
      LOG_ERROR(logger, "Resource without name, ignoring");
      continue;
    }
 
    Value resource(kObjectType);
    switch (resDef.type) {
    case ResourceTypes::Unknown:
      LOG_ERROR(logger, "Unknown resource type encountered, ignoring");
      continue;
    case ResourceTypes::Asset:      resource.AddMember("type", "Asset", ctx.alloc);      break;
    case ResourceTypes::Model:      resource.AddMember("type", "Model", ctx.alloc);      break;
    case ResourceTypes::Texture:      resource.AddMember("type", "Texture", ctx.alloc);      break;
    case ResourceTypes::Effect:      resource.AddMember("type", "Effect", ctx.alloc);      break;
    case ResourceTypes::Material:      resource.AddMember("type", "Material", ctx.alloc);      break;
    case ResourceTypes::MaterialInstance:      resource.AddMember("type", "MaterialInstance", ctx.alloc);      break;
    case ResourceTypes::Mesh:      resource.AddMember("type", "Mesh", ctx.alloc);      break;
    case ResourceTypes::Buffer:      resource.AddMember("type", "Buffer", ctx.alloc);      break;
    case ResourceTypes::Font:      resource.AddMember("type", "Font", ctx.alloc);
      break;
    case ResourceTypes::Gui:
      resource.AddMember("type", "Gui", ctx.alloc);
      break;
    default:
      assert(false && "Invalid enum");
      return false;
    }
    if (!resDef.source.empty()) {
      resource.AddMember("source", ctx.encodeString(resDef.source), ctx.alloc);
    }
 
    switch (resDef.type) {
    case ResourceTypes::Material:
    case ResourceTypes::MaterialInstance:
      if (!resDef.material.empty()) resource.AddMember("material", ctx.encodeString(resDef.material), ctx.alloc);
      if (!resDef.permutation.empty()) resource.AddMember("permutation", ctx.encodeString(resDef.material), ctx.alloc);
      if (!resDef.options.empty()) {
        Value options(kObjectType);
        for (const auto& item : resDef.options) {
          options.AddMember(ctx.encodeString(item.first), ctx.encodeString(item.second), ctx.alloc);
        }
        resource.AddMember("options", options, ctx.alloc);
      }
      if (!resDef.variants.empty()) {
        Value options(kObjectType);
        for (const auto& item : resDef.variants) {
          options.AddMember(ctx.encodeString(item.first), ctx.encodeString(item.second), ctx.alloc);
        }
        resource.AddMember("variants", options, ctx.alloc);
      }
      if (!resDef.properties.empty()) {
        for (auto& item : resDef.properties) {
          resource.AddMember(ctx.encodeString(item.first), encodeFieldValue(ctx, item.second), ctx.alloc);
        }
      }
      break;
    default:
      break;
 
 
    }
 
    resources.AddMember(ctx.encodeString(resDef.name), resource, ctx.alloc);
  }
 
  Value roots(kArrayType);
  for (size_t i = 0; i < definition.scene.entities.size(); i++) {
    const SceneEntityDefinition& entityDef = definition.scene.entities[i];
    if (entityDef.parentIndex == ::NoValue) {
 
      Value entity(kObjectType);
      if (!writeEntityItem(ctx, entity, definition, i)) return false;
      roots.PushBack(entity, ctx.alloc);
    }
  }
 
  return writeDoc(ctx, roots, resources, path);
}
 
#else
 
bool Cogs::Core::writeAsset(Context * /*context*/, StringView /*fileName*/, AssetWriteFlags /*flags*/, ComponentModel::Entity * /*root*/)
{
  return false;
}
 
bool Cogs::Core::writeAsset(class Context* /*context*/, const char* /*path*/, AssetHandle /*asset*/, AssetWriteFlags /*writeFlags*/)
{
  return false;
}
 
#endif