EntityReader.cpp

#include "EntityReader.h"
 
#include "Types.h"
#include "EntityStore.h"
#include "ReaderCommon.h"
#include "ResourceReader.h"
 
#include "Utilities/Parsing.h"
 
#include "Foundation/Logging/Logger.h"
#include "Foundation/HashFunctions.h"
 
#include <glm/glm.hpp>
#include <glm/gtx/quaternion.hpp>
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("EntityReader");
}
 
namespace Cogs::Core
{
  void readMaterialInstanceField(Context * context, const Value & value, FieldValue & fieldValue, ExpressionContext * ec)
  {
    fieldValue.type = DefaultValueType::MaterialInstance;
 
    static_assert(sizeof(MaterialInstanceDefinition) <= sizeof(fieldValue.storage));
    auto & materialInstance = *(new (fieldValue.storage) MaterialInstanceDefinition());
    materialInstance.type = ResourceTypes::MaterialInstance;
 
    if (value.IsString()) {
      std::string v = toString(value);
 
      if (v[0] == '$') {
        materialInstance.reference = v.substr(1);
      } else {
        // Just the type indicated, all other properties default.
        materialInstance.material = v;
      }
    } else if (value.IsObject()) {
      ReaderContext rc{ context, ec, nullptr };
      readMaterialInstanceDefinition(&rc, value, materialInstance);
    }
  }
}
 
void Cogs::Core::readEntityDefaults(Context * context, const Value & value, std::vector<FieldValue> & defaultValues, ExpressionContext * ec)
{
  if (value.IsArray()) {
    for (auto & d : value.GetArray()) {
      readFieldValues(context, d.MemberBegin()->value, toKey(d.MemberBegin()->name), defaultValues, ec);
    }
  }
  else if (value.IsObject()) {
    for (auto & d : value.GetObject()) {
      readFieldValues(context, d.value, toKey(d.name), defaultValues, ec);
    }
  }
}
 
bool Cogs::Core::readFieldValue(Context * context, const Value & jsonValue, const Reflection::Type & type, const StringView & fieldName, std::vector<FieldValue>& fieldValues, ExpressionContext * ec)
{
  const auto field = type.getField(fieldName.to_string());
 
  if (!field) {
    LOG_ERROR(logger, "Field \"%.*s\" not found in type %s.", StringViewFormat(fieldName), type.getName().c_str());
 
    return false;
  }
 
  if (jsonValue.IsNull()) {
    return false;
  }
 
  const auto & fieldType = Reflection::TypeDatabase::getType(field->getTypeId());
 
  FieldValue value = {};
  value.componentId = type.getTypeId();
  value.fieldId = type.getFieldId(field);
 
  if (fieldType.isEnum()) {
    if (jsonValue.IsString()) {
      if (fieldType.isEnumFlags()) {
        value.intValue = parseEnumFlags(toKey(jsonValue), fieldType, value.intValue);
      }
      else {
        value.intValue = parseEnum(toKey(jsonValue), fieldType, value.intValue);
      }
      value.type = DefaultValueType::Enum;
    }
    else if (jsonValue.IsNumber()) {
      value.type = DefaultValueType::Enum;
      if (jsonValue.IsInt()) {
        value.intValue = jsonValue.GetInt();
      }
      else {
        value.intValue = (int)jsonValue.GetDouble();
      }
    }
    else {
      LOG_ERROR(logger, "Invalid enum of field: %.*s of type %s.", StringViewFormat(fieldName), type.getName().c_str());
    }
  }
  else if (fieldType == Reflection::TypeDatabase::getType<bool>()) {
    if (jsonValue.IsBool()) {
      value.boolValue = jsonValue.GetBool();
      value.type = DefaultValueType::Bool;
    }
    else if (jsonValue.IsString()) {
      value.boolValue = readValue<bool>(jsonValue, ec);
      value.type = DefaultValueType::Bool;
    }
    else {
      LOG_ERROR(logger, "Invalid bool of field: %.*s of type %s.", StringViewFormat(fieldName), type.getName().c_str());
    }
  }
  else if (fieldType == Reflection::TypeDatabase::getType<glm::vec2>()) {
    readArray(jsonValue, value.float2, ec);
    value.type = DefaultValueType::Vec2;
  }
  else if (fieldType == Reflection::TypeDatabase::getType<glm::vec3>()) {
    readArray(jsonValue, value.float3, ec);
    value.type = DefaultValueType::Vec3;
  }
  else if (fieldType == Reflection::TypeDatabase::getType<glm::vec4>()) {
    readArray(jsonValue, value.float4, ec);
    value.type = DefaultValueType::Vec4;
  }
  else if (fieldType == Reflection::TypeDatabase::getType<glm::mat4>()) {
    readArray(jsonValue, glm::value_ptr(value.mat4), 16, ec);
    value.type = DefaultValueType::Mat4;
  }
  else if (fieldType == Reflection::TypeDatabase::getType<glm::dvec2>()) {
    readArray(jsonValue, value.double2, ec);
    value.type = DefaultValueType::DVec2;
  }
  else if (fieldType == Reflection::TypeDatabase::getType<glm::dvec3>()) {
    readArray(jsonValue, value.double3, ec);
    value.type = DefaultValueType::DVec3;
  }
  else if (fieldType == Reflection::TypeDatabase::getType<glm::dvec4>()) {
    readArray(jsonValue, value.double4, ec);
    value.type = DefaultValueType::DVec4;
  }
  else if (fieldType == Reflection::TypeDatabase::getType<glm::quat>()) {
    bool success = false;
    auto arr = jsonValue.GetArray();
    if (arr.Size() == 2) {
      if (arr[0].IsArray()) {
        auto A0 = arr[0].GetArray();
        if (A0.Size() == 3) {
          if (arr[1].IsArray()) {
            auto A1 = arr[1].GetArray();
            if (A1.Size() == 3) {
              // Vector-to-vector form
              glm::vec3 src, dst;
              readArray(arr[0], src, ec);
              readArray(arr[1], dst, ec);
              value.quat = glm::rotation(glm::normalize(src), glm::normalize(dst));
              success = true;
            }
          } else if (arr[1].IsNumber() || arr[1].IsString()) {
            // Axis-angle form
            glm::vec3 axisValue;
            readArray(arr[0], axisValue, ec);
            float angleValue = readValue(arr[1], 1.0f, ec);
            value.quat = glm::angleAxis(angleValue, axisValue);
            success = true;
          }
        }
      }
    }
    else if (arr.Size() == 4) {
      // Raw quaternion form
      readArray(jsonValue, value.float4, ec);
      success = true;
    }
    value.type = DefaultValueType::Quaternion;
    if (success == false) {
      LOG_ERROR(logger, "Failed to parse quaternion of field: %.*s of type %s.", StringViewFormat(fieldName), type.getName().c_str());
    }
  } else if (fieldType == Reflection::TypeDatabase::getType<MaterialInstanceHandle>()) {
    readMaterialInstanceField(context, jsonValue, value, ec);
  } else if (fieldType == Reflection::TypeDatabase::getType<ModelHandle>()) {
    value.type = DefaultValueType::Model;
    value.value = jsonValue.GetString();
  } else if (fieldType == Reflection::TypeDatabase::getType<AssetHandle>()) {
    value.type = DefaultValueType::Asset;
    value.value = jsonValue.GetString();
  }else if (fieldType == Reflection::TypeDatabase::getType<GuiDocumentHandle>()) {
    value.type = DefaultValueType::Gui;
    value.value = jsonValue.GetString();
  } else if (fieldType == Reflection::TypeDatabase::getType<MeshHandle>()) {
    value.type = DefaultValueType::Mesh;
    if (jsonValue.IsString()) {
      auto meshName = toString(jsonValue);
      if (meshName.size() < 2 || meshName[0] != '$') {
        LOG_ERROR(logger, "Mesh field must be set to existing field resource using $Name syntax.");
        return false;
      }
      value.value = meshName.substr(1);
    } else {
      ResourceDefinition def;
      value.value = readMesh(context, def, jsonValue).to_string();
    }
  } else if (fieldType == Reflection::TypeDatabase::getType<TextureHandle>()) {
    value.type = DefaultValueType::Texture;
    value.value = toString(jsonValue);
  } else if (fieldType == Reflection::TypeDatabase::getType<std::string>()) {
    value.type = DefaultValueType::String;
    value.value = toString(jsonValue);
  } else if (fieldType == Reflection::TypeDatabase::getType<std::vector<std::string>>()) {
    value.type = DefaultValueType::MultiString;
    auto arr = jsonValue.GetArray();
    for (auto & element : arr) {
      value.values.push_back(toString(element));
    }
  } else if (fieldType == Reflection::TypeDatabase::getType<std::vector<int>>()) {
    value.type = DefaultValueType::IntArray;
    auto arr = jsonValue.GetArray();
    for (auto & element : arr) {
      value.intValues.push_back(element.GetInt());
    }
  } else if (fieldType == Reflection::TypeDatabase::getType<std::vector<float>>()) {
    value.type = DefaultValueType::FloatArray;
    auto arr = jsonValue.GetArray();
    for (auto & element : arr) {
      value.floatValues.push_back(element.GetFloat());
    }
  } else if (fieldType == Reflection::TypeDatabase::getType<std::vector<glm::vec2>>()) {
    value.type = DefaultValueType::Vec2Array;
    auto arr = jsonValue.GetArray();
    if (!arr.Empty()) {
      const auto & first = arr.Begin();
 
      if (first->IsArray()) {
        for (auto & a : arr) {
          glm::vec2 v{};
          if (readArray(a, v, ec) != 2) {
            LOG_WARNING(logger, "Vector length mismatch in %s.", field->getName().c_str());
          }
 
          value.vec2Values.push_back(v);
        }
      } else if ((arr.Size() % 2) == 0) {
        for (unsigned int indx = 0; indx < arr.Size(); indx += 2) {
          value.vec2Values.push_back(glm::vec2{ readValue(arr[indx], 0.0f, ec), readValue(arr[indx + 1], 0.0f, ec) });
        }
      } else {
        LOG_ERROR(logger, "Invalid length of %s in entity type %s.",
                  field->getName().c_str(),
                  type.getName().c_str());
      }
    }
  } else if (fieldType == Reflection::TypeDatabase::getType<std::vector<glm::vec3>>()) {
    value.type = DefaultValueType::Vec3Array;
    auto arr = jsonValue.GetArray();
    if (!arr.Empty()) {
      const auto & first = arr.Begin();
 
      if (first->IsArray()) {
        for (auto & a : arr) {
          glm::vec3 v{};
          if (readArray(a, v, ec) != 3) {
            LOG_WARNING(logger, "Vector length mismatch in %s.", field->getName().c_str());
          }
 
          value.vec3Values.push_back(v);
        }
      } else if ((arr.Size() % 3) == 0) {
        for (unsigned int indx = 0; indx < arr.Size(); indx += 3) {
          value.vec3Values.push_back(glm::vec3{ readValue(arr[indx], 0.0f, ec), readValue(arr[indx + 1], 0.0f, ec), readValue(arr[indx + 2], 0.0f, ec) });
        }
      } else {
        LOG_ERROR(logger, "Invalid length of %s in entity type %s.",
                  field->getName().c_str(),
                  type.getName().c_str());
      }
    }
  } else if (fieldType == Reflection::TypeDatabase::getType<std::vector<glm::vec4>>()) {
    value.type = DefaultValueType::Vec4Array;
    auto arr = jsonValue.GetArray();
    if (!arr.Empty()) {
      const auto & first = arr.Begin();
 
      if (first->IsArray()) {
        for (auto & a : arr) {
          glm::vec4 v{};
          if (readArray(a, v, ec) != 4) {
            LOG_WARNING(logger, "Vector length mismatch in %s.", field->getName().c_str());
          }
 
          value.vec4Values.push_back(v);
        }
      } else if ((arr.Size() % 4) == 0) {
        for (unsigned int indx = 0; indx < arr.Size(); indx += 4) {
          value.vec4Values.push_back(glm::vec4{ readValue(arr[indx], 0.0f, ec), readValue(arr[indx + 1], 0.0f, ec), readValue(arr[indx + 2], 0.0f, ec), readValue(arr[indx + 3], 0.0f, ec) });
        }
      } else {
        LOG_ERROR(logger, "Invalid length of %s in entity type %s.",
                  field->getName().c_str(),
                  type.getName().c_str());
      }
    }
  } else if (fieldType == Reflection::TypeDatabase::getType<EntityPtr>() || fieldType == Reflection::TypeDatabase::getType<WeakEntityPtr>()) {
    value.type = DefaultValueType::Entity;
    value.value = toString(jsonValue);
  } else if (fieldType == Reflection::TypeDatabase::getType<std::vector<EntityPtr>>() || fieldType == Reflection::TypeDatabase::getType<std::vector<WeakEntityPtr>>()) {
    value.type = DefaultValueType::EntityArray;
    auto arr = jsonValue.GetArray();
    for (auto & element : arr) {
      value.values.push_back(toString(element));
    }
  } else {
    auto ext = getExtensionReader(fieldType.getTypeId());
 
    if (ext) {
      value.type = DefaultValueType::Extension;
      value.value = toString(jsonValue);
    } else if (fieldType == Reflection::TypeDatabase::getType<float>()) {
      value.type = DefaultValueType::Float;
      value.floatValue = readValue<float>(jsonValue, 0.0f, ec);
    } else if (fieldType == Reflection::TypeDatabase::getType<uint32_t>()) {
      value.type = DefaultValueType::Int;
      value.intValue = readValue<int>(jsonValue, ec);
    }
    else if (fieldType == Reflection::TypeDatabase::getType<int32_t>()) {
      value.type = DefaultValueType::Int;
      value.intValue = readValue<int>(jsonValue, ec);
    }
    else {
      LOG_WARNING(logger, "Value defined for Field: %s, Component type: %s Unsupported.",
        field->getName().c_str(),
        type.getName().c_str());
      return false;
    }
  }
 
  if (value.fieldId != Reflection::NoField) {
    fieldValues.push_back(value);
  } else {
    LOG_ERROR(logger, "Value defined for field %s which was not found on entity type %s.",
      field->getName().c_str(),
      type.getName().c_str());
  }
 
  return true;
}
 
bool Cogs::Core::readFieldValues(Context * context, const Value & jsonFieldValues, const StringView & typeName, std::vector<FieldValue> & fieldValues, ExpressionContext * ec)
{
  const auto & type = Reflection::TypeDatabase::getType(typeName);
 
  if (!type.isValid()) {
    LOG_ERROR(logger, "Type \"%.*s\" invalid.", StringViewFormat(typeName));
 
    return false;
  }
 
  if (!jsonFieldValues.IsObject()) return false;
 
  auto valuesObject = jsonFieldValues.GetObject();
 
  if (valuesObject.ObjectEmpty()) {
    FieldValue value = {};
    value.componentId = type.getTypeId();
 
    fieldValues.push_back(value);
  }
 
  bool success = true;
  for (auto & member : valuesObject) {
    const auto fieldName = toKey(member.name);
 
    if (!fieldName.size()) {
      LOG_ERROR(logger, "Field name cannot be empty.");
 
      continue;
    }
 
    success &= readFieldValue(context, member.value, type, fieldName, fieldValues, ec);
  }
 
  return success;
}
 
void Cogs::Core::readEntityDefinition(EntityStore * store, const StringView & name, const Value & value)
{
  EntityDefinition definition;
 
  readEntityDefinition(store, name, value, definition);
 
  if (!definition.name.empty()) {
    store->addEntityDefinition(definition);
  } else {
    LOG_WARNING(logger, "Discarding anonymous entity definition.");
  }
}
 
bool Cogs::Core::readEntityDefinition(EntityStore * store, const StringView & name, const Value & value, EntityDefinition & definition)
{
  if (name.size()) definition.name = name.to_string();
 
  if (value.IsString()) {
    StringView aliasedName(value.GetString(), value.GetStringLength());
    auto       aliasedDefinition = store->getEntityDefinition(aliasedName);
 
    if (!aliasedDefinition) {
      LOG_ERROR(logger, "Cannot alias unknown enitity definition %.*s.", StringViewFormat(aliasedName));
 
      return false;
    }
 
    definition.components = aliasedDefinition->components;
    definition.defaultValues = aliasedDefinition->defaultValues;
 
    return true;
  } else if (!value.IsObject()) {
    LOG_ERROR(logger, "Invalid JSON value structure.");
    return false;
  }
 
  ExpressionContext ec;
  ec.add("true", 1);
  ec.add("false", 0);
 
  for (const auto & member : value.GetObject()) {
    auto key = StringView(member.name.GetString());
 
    if (key == "name") {
      definition.name = member.value.GetString();
    } else if (key == "description") {
#if !defined( EMSCRIPTEN )
      definition.description = member.value.GetString();
#endif
    } else if (key == "components") {
      auto arr = member.value.GetArray();
 
      if (!arr.Size()) {
        LOG_WARNING(logger, "Entity definition created for %s with zero components defined.", definition.name.c_str());
      }
 
      for (auto & m : arr) {
        definition.components.push_back(m.GetString());
      }
    } else if (key == "defaults") {
      readEntityDefaults(store->getContext(), member.value, definition.defaultValues, &ec);
    } else if (key == "inherits") {
      StringView inheritedName(member.value.GetString(), member.value.GetStringLength());
      auto       inheritedDefinition = store->getEntityDefinition(inheritedName);
 
      if (!inheritedDefinition) {
        LOG_ERROR(logger, "Cannot inherit unknown enitity definition %.*s.", StringViewFormat(inheritedName));
 
        return false;
      }
 
      for (auto & c : inheritedDefinition->components) {
        definition.components.push_back(c);
      }
 
      for (auto & d : inheritedDefinition->defaultValues) {
        definition.defaultValues.push_back(d);
      }
    } else {
      readFieldValues(store->getContext(), member.value, key, definition.defaultValues, &ec);
    }
  }
 
  return !definition.name.empty();
}
 
void Cogs::Core::readEntityDefinition(const StringView & content, EntityStore * entityStore)
{
  auto document = parseJson(content, JsonParseFlags::NoCachedContent);
 
  readEntityDefinition(entityStore, "", document);
}