ResourceReader.cpp

#include "ResourceReader.h"
 
#include "Foundation/Logging/Logger.h"
 
#include "Context.h"
#include "Scene.h"
 
#include "Resources/MeshManager.h"
#include "Resources/MaterialManager.h"
#include "Resources/AssetManager.h"
 
#include "Generators/MeshGenerator.h"
 
#include "Services/Services.h"
#include "Services/TaskManager.h"
 
#include "Utilities/Parsing.h"
 
#include "ReaderCommon.h"
 
#include "Types.h"
 
namespace
{
  std::unordered_map<size_t, Cogs::Core::ReaderExtension> extensions;
 
  const Cogs::Logging::Log logger = Cogs::Logging::getLogger("ResourceReader");
}
 
namespace Cogs::Core
{
  StringView readMesh(Context * context, ResourceDefinition & definition, const Value & jsonResource)
  {
    // Must set explicit name to enable lookup. Else clears and replaces existing unnamed mesh.
    Cogs::Core::MeshHandle existing;
 
    if (!definition.name.empty()) {
      existing = context->meshManager->getMesh(definition.name);
    }
 
    Cogs::Core::MeshHandle mesh = existing ? existing : context->meshManager->create();
 
    if (definition.name.empty()) {
      static int seq = 0;
      std::string generatedName = "GeneratedMesh" + std::to_string(seq++);
      mesh->setName(generatedName);
    } else {
      mesh->setName(definition.name);
    }
 
    mesh->clear();
 
    for (auto & m : jsonResource.GetObject()) {
      auto key = toKey(m.name);
 
      if (key == "positions") {
        auto arr = m.value.GetArray();
 
        std::vector<glm::vec3> v(arr.Size());
 
        int i = 0;
        for (auto & element : arr) {
          readArray(element, v[i++], nullptr);
        }
 
        mesh->setPositions(v);
      } else if (key == "instancePositions") {
        auto arr = m.value.GetArray();
 
        std::vector<glm::vec3> v(arr.Size());
 
        int i = 0;
        for (auto & element : arr) {
          readArray(element, v[i++], nullptr);
        }
 
        mesh->setInstancePositions(v);
      } else if (key == "instanceColors") {
        auto arr = m.value.GetArray();
 
        std::vector<glm::vec4> v(arr.Size());
 
        int i = 0;
        for (auto & element : arr) {
          readArray(element, v[i++], nullptr);
        }
 
        mesh->setInstanceColors(v);
      } else if (key == "normals") {
        auto arr = m.value.GetArray();
 
        std::vector<glm::vec3> v(arr.Size());
 
        int i = 0;
        for (auto & element : arr) {
          readArray(element, v[i++], nullptr);
        }
 
        mesh->setNormals(v);
      } else if (key == "bbox") {
        auto arr = m.value.GetArray();
 
        std::vector<glm::vec3> v(arr.Size());
 
        int i = 0;
        for (auto & element : arr) {
          readArray(element, v[i++], nullptr);
        }
 
        if (v.size() == 2) {
          mesh->setBounds({ v[0], v[1] });
        }
      } else if (key == "generator") {
        ShapeDefinition definition2;
        definition2.size = glm::vec3(1, 1, 1);
 
        for (auto & g : m.value.GetObject()) {
          auto gKey = toKey(g.name);
 
          if (gKey == "shape") {
            definition2.type = parseEnum(toKey(g.value), ShapeType::None);
          } else if (gKey == "samples") {
            if (g.value.IsInt()) {
              definition2.refinement = g.value.GetInt();
            } else {
              definition2.refinement = parseInt(toKey(g.value), 16);
            }
          } else if (gKey == "size") {
            readArray(g.value, definition2.size, nullptr);
          }
        }
 
        context->services->getService<MeshGenerator>()->getMesh(mesh.resolve(), definition2);
      }
    }
 
    return mesh->getName();
  }
 
  void readAssetDefinition(ReaderContext* /*context*/, const Value& jsonResource, ResourceDefinition& assetDefinition)
  {
    assetDefinition.type = ResourceTypes::Asset;
    assetDefinition.source = toString(jsonResource["source"]);
  }
 
  void readModelDefinition(ReaderContext *, const Value & jsonResource, ResourceDefinition & definition)
  {
    definition.type = ResourceTypes::Model;
    definition.source = toString(jsonResource["source"]);
  }
 
  void readTextureDefinition(ReaderContext * /*context*/, const Value & jsonResource, ResourceDefinition & definition)
  {
    definition.type = ResourceTypes::Texture;
 
    auto & textureDescription = definition.textureDescription;
 
    for (auto & m : jsonResource.GetObject()) {
      auto key = toKey(m.name);
 
      if (key == "source") {
        definition.source = toString(m.value);
 
        if (jsonResource.HasMember("flags")) {
          auto flags = toKey(jsonResource["flags"]);
 
          auto splits = split(flags, "|");
 
          for (auto & s : splits) {
            if (s == "LinearColorSpace") {
              definition.loadFlags |= TextureLoadFlags::LinearColorSpace;
            }
          }
        }
      } else if (key == "generator") {
        definition.textureGenerator = true;
        ImageDefinition& imageDefinition = definition.imageDefinition;
        for (auto & g : m.value.GetObject()) {
          switch (toView(g.name).hash()) {
          case Cogs::hash("image"):
            imageDefinition.type = parseEnum(toKey(g.value), ImageType::None);
            break;
          case Cogs::hash("width"):
            imageDefinition.width = readValue<int>(g.value, ImageDefinition().width, nullptr);
            break;
          case Cogs::hash("height"):
            imageDefinition.height = readValue<int>(g.value, ImageDefinition().height, nullptr);
            break;
          case Cogs::hash("layers"):
            imageDefinition.layers = readValue<int>(g.value, ImageDefinition().layers, nullptr);
            break;
          default:
            break;
          }
        }
      } else if (key == "width") {
        textureDescription.width = readValue<int>(m.value, 1024, nullptr);
      } else if (key == "height") {
        textureDescription.height = readValue<int>(m.value, 1024, nullptr);
      } else if (key == "renderTarget") {
        textureDescription.flags |= TextureFlags::RenderTarget;
      } else if (key == "format") {
        textureDescription.format = parseTextureFormat(toKey(m.value), Cogs::TextureFormat::R8G8B8A8_UNORM_SRGB);
      } else if (key == "flags") {
        TokenStream flags;
        split(toKey(m.value), " |", flags);
 
        for (auto & flag : flags) {
          if (flag == "Texture") {
            textureDescription.flags |= TextureFlags::Texture;
          } else if (flag == "RenderTarget") {
            textureDescription.flags |= TextureFlags::RenderTarget;
          } else if (flag == "GenerateMipMaps") {
            textureDescription.flags |= TextureFlags::GenerateMipMaps;
          }
        }
      }
    }
  }
 
  void parseMaterialInstanceProperty(const Value & value, const StringView & key, const Material * material, FieldValue & propertyValue, ExpressionContext * ec)
  {
    if (value.IsFloat()) {
      propertyValue.type = DefaultValueType::Float;
      propertyValue.floatValue = value.GetFloat();
    } else if (value.IsBool()) {
      propertyValue.type = DefaultValueType::Bool;
      propertyValue.boolValue = value.GetBool();
    } else if (value.IsInt()) {
      propertyValue.type = DefaultValueType::Int;
      propertyValue.intValue = value.GetInt();
    } else if (value.IsArray()) {
      auto arr = value.GetArray();
 
      if (arr.Size() == 2) {
        propertyValue.type = DefaultValueType::Vec2;
        readArray(value, propertyValue.float2, ec);
      } else if (arr.Size() == 3) {
        propertyValue.type = DefaultValueType::Vec3;
        readArray(value, propertyValue.float3, ec);
      } else if (arr.Size() == 4) {
        propertyValue.type = DefaultValueType::Vec4;
        readArray(value, propertyValue.float4, ec);
      } else {
        LOG_ERROR(logger, "Unsupported array size for material property %.*s", StringViewFormat(key));
      }
    } else if (value.IsString()) {
      ParsedValue parsedValue;
      parseStringValue(toKey(value), parsedValue);
 
      if (parsedValue.type == ParsedDataType::Unknown) parsedValue.type = ParsedDataType::String;
 
      if (parsedValue.type == ParsedDataType::Float) {
        propertyValue.type = DefaultValueType::Float;
        propertyValue.floatValue = parsedValue.floatValue;
      } else if (parsedValue.type == ParsedDataType::Float2) {
        propertyValue.type = DefaultValueType::Vec2;
        propertyValue.float2 = parsedValue.float2Value;
      } else if (parsedValue.type == ParsedDataType::Float3) {
        propertyValue.type = DefaultValueType::Vec3;
        propertyValue.float3 = parsedValue.float3Value;
      } else if (parsedValue.type == ParsedDataType::Float4) {
        propertyValue.type = DefaultValueType::Vec4;
        propertyValue.float4 = parsedValue.float4Value;
      } else if (parsedValue.type == ParsedDataType::String) {
        if (material) {
          auto texKey = material->getTextureKey(key);
          if (texKey != NoProperty) {
            propertyValue.type = DefaultValueType::Texture;
            propertyValue.value = parsedValue.value;
          } else {
            auto floatKey = material->getFloatKey(key);
            if (floatKey != NoProperty) {
              propertyValue.type = DefaultValueType::Float;
              propertyValue.floatValue = ec->eval(parsedValue.value, 0.0f);
            }
          }
        } else {
          propertyValue.type = DefaultValueType::Texture;
          propertyValue.value = parsedValue.value;
        }
      }
    } else {
      LOG_ERROR(logger, "Unsupported material property value for %.*s", StringViewFormat(key));
    }
  }
 
  void readMaterialInstanceDefinition(ReaderContext * rc, const Value & value, ResourceDefinition & resourceDefinition)
  {
    resourceDefinition.type = ResourceTypes::MaterialInstance;
 
    auto & materialInstance = resourceDefinition;
    auto context = rc->context;
 
    // Complex material instance defaults.
    auto obj = value.GetObject();
 
    MaterialHandle material;
 
    for (auto & m : obj) {
      auto matKey = toKey(m.name);
 
      auto keyCode = StringView(matKey.data(), matKey.length()).hash();
 
      switch (keyCode) {
      case Cogs::hash("type"):
        if (rc->ec) {
          materialInstance.material = m.value.GetString();
          material = context->materialManager->getMaterial(materialInstance.material);
        }
        break;
      case Cogs::hash("material"):
        materialInstance.material = m.value.GetString();
        break;
      case Cogs::hash("permutation"):
        materialInstance.permutation = m.value.GetString();
        break;
      case Cogs::hash("options"):
      {
        auto optionsObject = m.value.GetObject();
 
        for (auto & option : optionsObject) {
          materialInstance.options[option.name.GetString()] = option.value.GetString();
        }
        break;
      }
      case Cogs::hash("variants"):
      {
        auto variantsObject = m.value.GetObject();
 
        for (auto & variant : variantsObject) {
          if (variant.value.IsNumber()) {
            materialInstance.variants[variant.name.GetString()] = std::to_string(variant.value.GetInt());
          } else if (variant.value.IsString()) {
            materialInstance.variants[variant.name.GetString()] = variant.value.GetString();
          } else if (variant.value.IsBool()) {
            materialInstance.variants[variant.name.GetString()] = variant.value.GetBool() ? "true" : "false";
          } else {
            LOG_ERROR(logger, "Unknown variant type.");
          }
        }
        break;
      }
      case Cogs::hash("properties"):
      {
        auto propsObject = m.value.GetObject();
 
        for (auto & prop : propsObject) {
          auto key = toKey(prop.name);
          auto & propertyValue = materialInstance.properties[key.to_string()];
 
          parseMaterialInstanceProperty(prop.value, key, material.resolve(), propertyValue, rc->ec);
        }
        break;
      }
      default:
        auto & propertyValue = materialInstance.properties[matKey.to_string()];
 
        parseMaterialInstanceProperty(m.value, matKey, material.resolve(), propertyValue, rc->ec);
 
        break;
      }
    }
  }
 
  void readResource(Context * context, const StringView & name, const Value & jsonResource)
  {
    ResourceDefinition definition;
 
    if (name.size()) definition.name = name.to_string();
 
    if (jsonResource.IsString()) {
      auto value = toKey(jsonResource);
 
      if (value.find(".material") != StringView::NoPosition) {
        context->materialManager->loadMaterial(value);
        context->materialManager->processLoading();
        return;
      }
    }
 
    ReaderContext rc;
    rc.context = context;
 
    for (auto & m : jsonResource.GetObject()) {
      auto key = toKey(m.name);
 
      if (key == "name") {
        definition.name = toString(m.value);
      } else if (key == "type") {
        auto type = toKey(m.value);
 
        if (type == "Mesh") {
          readMesh(context, definition, jsonResource);
        } else if (type == "Asset") {
          readAssetDefinition(&rc, jsonResource, definition);
          context->assetManager->instantiateAsset(AssetHandle::NoHandle, definition);
        } else if (type == "MaterialInstance") {
          readMaterialInstanceDefinition(&rc, jsonResource, definition);
          context->assetManager->instantiateMaterialInstance(AssetHandle::NoHandle, definition);
        } else if (type == "Texture") {
          readTextureDefinition(&rc, jsonResource, definition);
          context->assetManager->instantiateTexture(AssetHandle::NoHandle, definition);
        } else if (type == "Model") {
          readModelDefinition(&rc, jsonResource, definition);
          context->assetManager->instantiateModel(AssetHandle::NoHandle, definition);
        } else if (type == "GuiDocument") {
          auto * mgr = context->engine->getResourceManagerByValueType((int)DefaultValueType::Gui);
          if (mgr) {
            mgr->readSource(context, definition, &jsonResource);
          }
          else {
            LOG_ERROR(logger, "No manager for DefaultValueType::Gui");
          }
        } else {
          auto ext = extensions.find(type.hash());
 
          if (ext != extensions.end()) {
            ext->second.readCallback(definition.name, jsonResource);
          }
        }
      }
    }
  }
 
  void readResourceDefinition(Context * context, const StringView & name, const Value & jsonResource, ResourceDefinition & definition)
  {
    if (name.size()) definition.name = name.to_string();
 
    if (jsonResource.IsString()) {
      auto value = toKey(jsonResource);
 
      if (value.find(".material") != StringView::NoPosition) {
        context->materialManager->loadMaterial(value);
        context->materialManager->processLoading();
        return;
      }
    }
 
    ReaderContext rc;
    rc.context = context;
 
    for (auto & m : jsonResource.GetObject()) {
      auto key = toKey(m.name);
 
      if (key == "name") {
        definition.name = toString(m.value);
      } else if (key == "type") {
        auto type = toKey(m.value);
 
        if (type == "Mesh") {
          readMesh(context, definition, jsonResource);
        } else if (type == "Asset") {
          readAssetDefinition(&rc, jsonResource, definition);
        } else if (type == "MaterialInstance") {
          readMaterialInstanceDefinition(&rc, jsonResource, definition);
        } else if (type == "Texture") {
          readTextureDefinition(&rc, jsonResource, definition);
        } else if (type == "Model") {
          readModelDefinition(&rc, jsonResource, definition);
        } else if (type == "GuiDocument") {
          auto * mgr = context->engine->getResourceManagerByValueType((int)DefaultValueType::Gui);
          if (mgr) {
            mgr->readSource(context, definition, &jsonResource);
          }
          else {
            LOG_ERROR(logger, "No manager for DefaultValueType::Gui");
          }
        } else {
          auto ext = extensions.find(type.hash());
 
          if (ext != extensions.end()) {
            ext->second.readCallback(definition.name, jsonResource);
          }
        }
      }
    }
  }
}
 
Cogs::Core::ReaderExtension * Cogs::Core::getExtensionReader(size_t code)
{
  for (auto & e : extensions) {
    if (e.second.handleTypeId == code) {
      return &e.second;
    }
  }
 
  return nullptr;
}
 
void Cogs::Core::registerExtensionReader(Context * /*context*/, const StringView & resourceType, const Reflection::Type & handleType, ReaderExtension extension)
{
  extension.handleTypeId = handleType.getTypeId();
 
  extensions[resourceType.hash()] = extension;
}
 
void Cogs::Core::readResources(Context * context, const Value & jsonResources, int /*flags*/)
{
  if (jsonResources.IsObject()) {
    for (auto & m : jsonResources.GetObject()) {
      readResource(context, toKey(m.name), m.value);
    }
  }
  else {
    LOG_ERROR(logger, "Expected resources section as JSON object");
  }
}
 
void Cogs::Core::readResourceDefinitions(Context * context, const Value & jsonResources, int /*flags*/, AssetDefinition & asset)
{
  if (jsonResources.IsObject()) {
    for (auto & m : jsonResources.GetObject()) {
      auto & resourceDefinition = asset.resources.emplace_back();
      readResourceDefinition(context, toKey(m.name), m.value, resourceDefinition);
    }
  }
}