SceneReader.cpp

#include "SceneReader.h"
 
#include <vector>
 
#include "Context.h"
 
#include "EntityPtr.h"
#include "EntityStore.h"
 
#include "Foundation/Logging/Logger.h"
 
#include "Utilities/Expressions.h"
#include "Utilities/Parsing.h"
 
#include "Components/Core/PropertiesComponent.h"
#include "Components/Core/AssetComponent.h"
 
#include "Resources/AssetManager.h"
 
#include "EntityReader.h"
#include "EntityCreator.h"
#include "ResourceReader.h"
 
#include <algorithm>
 
namespace
{
  using namespace Cogs::Core;
 
  constexpr size_t PreAllocSize = 64ULL;
 
  constexpr uint32_t NoIndex = static_cast<uint32_t>(-1);
 
  const Cogs::Logging::Log logger = Cogs::Logging::getLogger("SceneReader");
 
  bool isTypeSomethingDifferent(const AssetDefinition& /*asset*/, const SceneEntityDefinition& entity, Cogs::StringView newTypeName)
  {
    if (entity.isAssetModelOrLodGroup() || ((entity.type != NoString) && (Strings::get(entity.type) != newTypeName))) {
      LOG_WARNING(logger, "Type already set to '%.*s', cannot set type to '%.*s'",
                  StringViewFormat(entity.getTypeName()),
                  StringViewFormat(newTypeName));
      return true;
    }
    return false;
  }
   
 
  void loopValues(Context* context, const Value& v, AssetDefinition& asset, SceneDefinition& sceneDef, uint32_t entityId, ExpressionContext* ev, size_t i)
  {
    auto& val = ev->getValues()[i];
 
    const uint32_t index = sceneDef.entities[entityId].index;
 
    val.value = val.min;
    while (val.value <= val.max) {
      if (i == 0) {
        for (auto& c : v.GetArray()) {
          uint32_t child = asset.scene.createEntity(index);
          readSceneEntityDefinition(context, c, asset, asset.scene, child, ev);
          asset.scene[index].numChildren++;
        }
      }
      else {
        loopValues(context, v, asset, asset.scene, index, ev, i - 1);
      }
 
      val.value += val.step;
      ++val.sequenceNumber;
    }
  }
 
  void replace(std::string& str, const std::string& from, const std::string& to)
  {
    size_t start_pos = str.find(from);
    if (start_pos != std::string::npos) {
      str.replace(start_pos, from.length(), to);
    }
  }
 
  void parseModelItem(Context* /*context*/, AssetDefinition& asset, SceneEntityDefinition& entity, const Value& modelValue)
  {
    SceneDefinition& scene = asset.scene;
 
    if (isTypeSomethingDifferent(asset, entity, "Model")) {
      entity.setError();
      return;
    }
 
    entity.setModel();
    entity.model.part = NoIndex;
    entity.model.size = 0;
 
    uint32_t lodDepth = 0;
    uint32_t pIndex = entity.parentIndex;
    while (pIndex != NoIndex) {
      const SceneEntityDefinition& e = scene[pIndex];
 
      if (e.isLodGroup()) ++lodDepth;
 
      pIndex = e.parentIndex;
    }
    entity.model.depth = (uint16_t)lodDepth;
 
    if (modelValue.IsObject()) {
      for (auto& mm : modelValue.GetObject()) {
 
        Cogs::StringView key = toView(mm.name);
        switch (Cogs::hash(key)) {
 
        case Cogs::hash("source"):
          if (mm.value.IsString()) {
            Cogs::StringView source = toView(mm.value);
            if (!source.empty()) {
              entity.model.index = scene.properties.addProperty("model", source);
            }
            else {
              LOG_ERROR(logger, "In 'model', value of 'source' is empty string");
              entity.setError();
            }
          }
          else if (mm.value.IsUint()) {
            // Compact notation, number gets interpreted as the filename xxxx/xxxx.cogsbin
            entity.model.index = scene.properties.addProperty("model", mm.value.GetUint());
          }
          else {
            LOG_ERROR(logger, "In 'model', value of 'source' is neither string nor uint");
            entity.setError();
          }
          break;
 
        case Cogs::hash("offset"):
        case Cogs::hash("part"):
          if (mm.value.IsUint()) {
            entity.model.part = mm.value.GetUint();
          }
          else if (mm.value.IsInt() && mm.value.GetInt() == -1) {
            entity.model.part = NoIndex;
          }
          else {
            LOG_ERROR(logger, "In 'model', value of '%.*s' is not an uint", StringViewFormat(key));
            entity.setError();
          }
          break;
 
        case Cogs::hash("kb"):
          if (mm.value.IsUint()) {
            entity.model.size = mm.value.GetUint();
          }
          else {
            LOG_ERROR(logger, "In 'model', value of kb is not an uint");
            entity.setError();
          }
          break;
 
        default:
          LOG_WARNING(logger, "In 'model', unrecognized key '%.*s'", StringViewFormat(key));
          break;
        }
      }
    }
 
    else if (modelValue.IsString()) {
      Cogs::StringView source = toView(modelValue);
      if (!source.empty()) {
        entity.model.index = scene.properties.addProperty("asset", source);
      }
      else {
        entity.setError();
      }
    }
 
    else if (modelValue.IsUint()) {
      entity.model.index = scene.properties.addProperty("model", modelValue.GetUint());
    }
 
    else {
      entity.setError();
      LOG_ERROR(logger, "Invalid model value.");
    }
 
  }
 
  void parseAssetItem(Context* context, AssetDefinition& asset, SceneEntityDefinition& entity, ExpressionContext* ec, const Value& assetValue)
  {
    SceneDefinition& scene = asset.scene;
 
    if (isTypeSomethingDifferent(asset, entity, "Asset")) {
      entity.setError();
      return;
    }
 
    entity.setAsset();
    entity.asset.material = NoIndex;
 
    if (assetValue.IsObject()) {
      for (auto& mm : assetValue.GetObject()) {
 
        Cogs::StringView key = toView(mm.name);
        switch (Cogs::hash(key)) {
 
        case Cogs::hash("source"):
          if (mm.value.IsString()) {
            entity.asset.index = scene.properties.addProperty("asset", toKey(mm.value));
          }
          else if (mm.value.IsUint()) {
            entity.asset.index = scene.properties.addProperty("asset", mm.value.GetUint());
          }
          else {
            LOG_ERROR(logger, "In 'asset', value of 'source' is neither a string nor an uint");
          }
          break;
 
        case Cogs::hash("flags"):
          if (mm.value.IsString()) {
            entity.asset.flags = uint32_t(parseEnumFlags(toView(mm.value), AssetFlags::None));
          }
          else if (mm.value.IsUint()) {
            // Compact notation, store numeric value directly
            entity.asset.flags = mm.value.GetUint();
          }
          else {
            LOG_ERROR(logger, "In 'asset', value of 'flags' is neither a string nor an uint");
          }
          break;
 
        case Cogs::hash("material"):
          if (mm.value.IsString()) {
            entity.asset.material = scene.properties.addProperty("material", toView(mm.value));
          }
          else if (mm.value.IsObject()) {
            ResourceDefinition& resource = asset.resources.emplace_back();
            ReaderContext rc;
            rc.context = context;
            rc.asset = nullptr;
            rc.ec = ec;
            readMaterialInstanceDefinition(&rc, mm.value, resource);
            // FIXME: doesn't look like entity.asset.material gets set?
          }
          else {
            LOG_ERROR(logger, "In 'asset', value of 'material' is neither a string nor an object");
          }
          break;
 
        default:
          LOG_WARNING(logger, "In 'asset', unrecognized key '%.*s'", StringViewFormat(key));
          break;
        }
      }
    }
 
    else if (assetValue.IsString()) {
      Cogs::StringView source = toView(assetValue);
      if (!source.empty()) {
        entity.asset.index = scene.properties.addProperty("asset", source);
      }
      else {
        entity.setError();
      }
    }
 
    else if (assetValue.IsUint()) {
      entity.asset.index = scene.properties.addProperty("asset", assetValue.GetUint());
    }
 
    else {
      entity.setError();
      LOG_ERROR(logger, "Invalid asset value.");
    }
  }
 
}
 
 
void Cogs::Core::readSceneEntityDefinition(Context* context, const Value& jsonEntity, AssetDefinition& asset, SceneDefinition& sceneDef, const uint32_t entityId, ExpressionContext* ec)
{
  if (!jsonEntity.IsObject()) {
    sceneDef[entityId].setError();
    LOG_ERROR(logger, "JSON parse Error in scene entity definition.");
    return;
  }
 
  SceneDefinition& scene = asset.scene;
 
  if (jsonEntity.GetObject().ObjectEmpty()) {
    sceneDef[entityId].setEmpty();
    return;
  }
 
  sceneDef[entityId].firstField = uint32_t(scene.fieldValues.size());
  sceneDef[entityId].firstChild = uint32_t(scene.entities.size());
 
  auto o = jsonEntity.GetObject();
 
  for (auto& m : o) {
    StringView key = toKey(m.name);
 
    if (key == "name") {
      std::string nameStr = m.value.GetString();
 
      if (ec && nameStr.find('%') != std::string::npos) {
 
        ExpressionContext* tec = ec;
        do {
          for (const ExpressionVariable& value : tec->getValues()) {
            replace(nameStr, "%" + value.name, std::to_string(value.sequenceNumber));
          }
          tec = tec->getParent();
        } while (tec != nullptr);
 
      }
 
      sceneDef[entityId].nameIndex = scene.properties.addProperty("name", nameStr);
    }
    else if (key == "objectId") {
      sceneDef[entityId].objectId = m.value.GetUint();
    }
    else if (key == "type") {
      StringView type = StringView(m.value.GetString());
      if (isTypeSomethingDifferent(asset, sceneDef[entityId], type)) {
        continue;
      }
      sceneDef[entityId].type = Strings::add(type);
    }
    else if (key == "model") {
      parseModelItem(context, asset, sceneDef[entityId], m.value);
     }
    else if (key == "asset") {
      parseAssetItem(context, asset, sceneDef[entityId], ec, m.value);
    }
    else if (key == "parent") {
      uint32_t parentPropertyIndex = scene.properties.addProperty("parent", toKey(m.value));
      sceneDef[entityId].parentIndex = parentPropertyIndex;
      sceneDef[entityId].flags |= SceneEntityFlags::ParentIsName;
    }
    else if (key == "properties") {
      PropertyStore& properties = scene.properties;
 
      SceneEntityDefinition& entity = sceneDef[entityId];
      entity.firstProperty = uint32_t(scene.properties.size());
 
      for (auto& c : m.value.GetObject()) {
        StringView propName = toKey(c.name);
        ++entity.numProperties;
 
        if (c.value.IsBool()) {
          properties.addProperty(propName, c.value.GetBool());
        }
        else if (c.value.IsString()) {
          properties.addProperty(propName, toKey(c.value));
        }
        else if (c.value.IsInt()) {
          properties.addProperty(propName, c.value.GetInt());
        }
        else if (c.value.IsFloat()) {
          properties.addProperty(propName, c.value.GetFloat());
        }
        else if (c.value.IsArray()) {
          auto valueArray = c.value.GetArray();
 
          if (valueArray.Empty()) {
            LOG_WARNING(logger, "Ignoring empty array in property \"%.*s\"", StringViewFormat(propName));
          }
          else {
 
            // Convert known array properties to expected type.
            switch (toKey(c.name).hash()) {
            case hash("ids"):
            {
              std::vector<uint32_t> uints(valueArray.Size());
              for (uint32_t i = 0; i < valueArray.Size(); ++i) {
                uints[i] = valueArray[i].GetUint();
              }
              properties.addProperty(propName, uints);
              break;
            }
 
            default:
            {
              std::vector<float> floats(valueArray.Size());
              for (uint32_t i = 0; i < valueArray.Size(); ++i) {
                floats[i] = valueArray[i].GetFloat();
              }
              properties.addProperty(propName, floats);
              break;
            }
            }
 
          }
 
 
 
 
        }
        else {
          StringView name = toKey(c.name);
          LOG_WARNING(logger, "Unsupported property type for key \"%.*s\".", StringViewFormat(name));
          --entity.numProperties;
        }
      }
    }
    else if (key == "children" || key == "lods") {
      // Skip
    }
    else if (key == "sequence") {
      sceneDef[entityId].setSequence();
 
      ExpressionContext expressionContext;
 
      expressionContext.inherit(ec);
 
      for (auto& v : m.value.GetObject()) {
        if (v.name == "variables") {
          for (auto& vv : v.value.GetObject()) {
 
            ExpressionVariable& var = expressionContext.add(toKey(vv.name), 0);
 
            if (vv.value.IsObject()) {
              if (!vv.value.HasMember("min") || !vv.value.HasMember("max") || !vv.value.HasMember("step")) {
                LOG_ERROR(logger, "Key variables: Invalid range specification.");
                continue;
              }
              var.min = vv.value["min"].GetDouble();
              var.max = vv.value["max"].GetDouble();
              var.step = vv.value["step"].GetDouble();
            }
            else if (vv.value.IsArray()) {
              if (vv.value.Size() != 3) {
                LOG_ERROR(logger, "Key variables: Invalid number of elements in array.");
                continue;
              }
              var.min = vv.value[0].GetDouble();
              var.max = vv.value[1].GetDouble();
              var.step = vv.value[2].GetDouble();
            }
          }
        }
      }
 
      for (auto& v : m.value.GetObject()) {
        if (v.name == "entities") {
          loopValues(context, v.value, asset, sceneDef, entityId, &expressionContext, expressionContext.getValues().size() - 1);
        }
      }
    }
    else {
      if (scene.fieldValues.empty()) {
        scene.fieldValues.reserve(PreAllocSize);
      }
 
      TokenStream tokens;
      split(key, ".", tokens);
 
      if (tokens.size() == 2) {
        // (Component . field) pair
        const Reflection::Type& type = Reflection::TypeDatabase::getType(tokens[0]);
 
        if (readFieldValue(context, m.value, type, tokens[1], scene.fieldValues, ec)) {
          ++sceneDef[entityId].numFields;
        }
      }
      else if (tokens.size() == 1) {
        size_t before = scene.fieldValues.size();
        readFieldValues(context, m.value, key, scene.fieldValues, ec);
        size_t after = scene.fieldValues.size();
 
        sceneDef[entityId].numFields += uint32_t(after - before);
      }
      else {
        LOG_ERROR(logger, "Unrecognized property name %.*s.", StringViewFormat(key));
      }
    }
  }
 
  uint32_t index = sceneDef[entityId].index;
 
  for (auto& m : o) {
    StringView key = toKey(m.name);
 
    if (key == "children") {
      if (!m.value.IsArray()) {
        LOG_ERROR(logger, "children property must be array type.");
        sceneDef[entityId].setError();
        continue;
      }
      uint32_t prevChild = NoIndex;
      if (m.value.GetArray().Empty()) {
        continue;
      }
      for (auto& c : m.value.GetArray()) {
        uint32_t child = scene.createEntity(index);
        if (prevChild != NoIndex) {
          scene[prevChild].nextSibling = child;
        }
        prevChild = child;
        ++scene[index].numChildren;
        readSceneEntityDefinition(context, c, asset, scene, child, ec);
      }
 
      if (scene[index].numChildren) scene[index].setChildren();
    }
    else if (key == "lods") {
      if (!m.value.IsArray()) {
        LOG_ERROR(logger, "lods property must be array type.");
        sceneDef[entityId].setError();
        continue;
      }
 
      if (isTypeSomethingDifferent(asset, scene[index], "LodGroup")) {
        scene[index].setError();
        continue;
      }
 
      ++scene.numLodGroups;
      scene[index].setLodGroup();
      scene[index].lod.numLods = 0;
      uint32_t prevChild = NoIndex;
 
      for (auto& c : m.value.GetArray()) {
 
        if (c.IsObject() || (c.IsArray() && c.Empty())) {
          uint32_t child = scene.createEntity(index);
          if (prevChild != NoIndex) {
            scene[prevChild].nextSibling = child;
          }
          prevChild = child;
          ++scene[index].numChildren;
          ++scene[index].lod.numLods;
          if (c.IsObject()) {
            readSceneEntityDefinition(context, c, asset, scene, child, ec);
          }
          else {
            // Note: If a lod-level is empty, we create an empty child  to represent
            // this, making ordering and count wrt error values correct.
            scene[child].setEmpty();
          }
        }
 
        else if (c.IsArray()) {
          uint32_t prevLod = NoIndex;
          for (auto& cc : c.GetArray()) {
            if (cc.IsObject()) {
              uint32_t child = scene.createEntity(index);
              if (prevChild != NoIndex) {
                scene[prevChild].nextSibling = child;
              }
 
              if (prevLod != NoIndex) {
                scene[prevLod].nextLodSibling = child;
              }
              prevLod = child;
              prevChild = child;
              ++scene[index].numChildren;
              readSceneEntityDefinition(context, cc, asset, scene, child, ec);
            }
            else {
              LOG_ERROR(logger, "Invalid lod child - must be object.");
            }
          }
          ++scene[index].lod.numLods;
        }
      }
 
      if (scene[index].numChildren) scene[index].setChildren();
    }
  }
}
 
void Cogs::Core::readScene(Context* context, const Value& jsonScene, AssetLoadFlags flags, ComponentModel::Entity* root)
{
  AssetDefinition asset;
  SceneDefinition& scene = asset.scene;
 
  readSceneDefinition(context, jsonScene, flags, asset);
 
  std::vector<ComponentModel::Entity*> entities(scene.entities.size());
 
  for (const SceneEntityDefinition& definition : scene.entities) {
    Entity* parent = nullptr;
    if (definition.isParentedByName()) {
      parent = root;
    }
    else if (definition.parentIndex == NoIndex) {
      parent = root;
    }
    else {
      const SceneEntityDefinition& parentDef = scene.entities[definition.parentIndex];
      if (parentDef.isSequence()) {
        // Sequence has no enity. Children shall be parented by optional root.
        parent = root;
      }
      else {
        parent = entities[definition.parentIndex];
      }
    }
 
    entities[definition.index] = createEntity(context, scene, definition, parent);
  }
}
 
void Cogs::Core::readSceneDefinition(Context* context, const Value& jsonScene, AssetLoadFlags /*flags*/, AssetDefinition& asset)
{
  ExpressionContext evaluationContext;
 
  if (!jsonScene.IsArray()) {
    LOG_ERROR(logger, "JSON Scene must be specified as an array.");
    return;
  }
 
  auto entityArray = jsonScene.GetArray();
  SceneDefinition& scene = asset.scene;
 
  scene.numTopLevelEntities = entityArray.Size();
  // Probably more entities in children.
  if (scene.entities.empty()) {
    scene.entities.reserve(std::max(size_t(entityArray.Size()), PreAllocSize));
  }
  scene.properties.addProperty(StringView(), StringView());
 
  for (auto& e : entityArray) {
    uint32_t index = scene.createEntity(NoParentEntity);
    readSceneEntityDefinition(context, e, asset, scene, index, &evaluationContext);
  }
 
  if (scene.entities.empty()) {
    LOG_WARNING(logger, "Read empty scene.");
  }
}