RenderPipelineReader.cpp

#include "RenderPipelineReader.h"
 
#include "JsonParser.h"
 
#include "Foundation/Logging/Logger.h"
 
#include <glm/fwd.hpp>
 
#include "Context.h"
#include "Bridge/Bridge.h"
 
#include "Resources/ResourceStore.h"
 
#include "Utilities/Parsing.h"
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("PipelineParser");
}
 
namespace Cogs
{
  namespace Core
  {
    RenderResourceType parseResourceType(const std::string & str)
    {
      if (str == "RenderList") {
        return RenderResourceType::RenderList;
      } else if (str == "Texture2D") {
        return RenderResourceType::RenderTexture;
      } else if (str == "RenderTarget") {
        return RenderResourceType::RenderTarget;
      } else if (str == "RenderBuffer") {
        return RenderResourceType::RenderBuffer;
      }
 
      return RenderResourceType::Unknown;
    }
 
    void parseOptions(const Value & jsonOptions, RenderPipelineDefinition & definition)
    {
      for (auto & o : jsonOptions.GetObject()) {
        auto name = toKey(o.name);
 
        ParsedOption option;
        option.key = name.to_string();
 
        if (!o.value.IsObject()) {
          LOG_ERROR(logger, "Option %.*s must be object type.", StringViewFormat(name));
          continue;
        }
 
        for (auto & v : o.value.GetObject()) {
          auto key = toKey(v.name);
 
          if (key == "values" && v.value.IsArray()) {
            for (auto & vv : v.value.GetArray()) {
              option.values.push_back(vv.GetString());
            }
          } else if (key == "setting") {
            option.setting = v.value.GetString();
          }
        }
 
        definition.options.push_back(option);
      }
    }
 
    void parseValue(const StringView & key, const Value & value, ParsedValue & v)
    {
      v.key = key.to_string();
 
      switch (value.GetType())
      {
      case kStringType:
      {
        parseStringValue(toKey(value), v);
      }
      break;
      case kObjectType:
      {
        v.type = ParsedDataType::Object;
 
        for (auto & m : value.GetObject()) {
          v.values.emplace_back();
          parseValue(toKey(m.name), m.value, v.values.back());
        }
      }
      break;
      case kNumberType:
        if (value.IsInt()) {
          v.type = ParsedDataType::Int;
          v.intValue = static_cast<int>(value.GetInt());
        } else {
          v.type = ParsedDataType::Float;
          v.floatValue = static_cast<float>(value.GetFloat());
        }
        break;
      case kArrayType:
      {
        auto arr = value.GetArray();
 
        if (arr.Size() < 1) {
          LOG_ERROR(logger, "Cannot deduce type from empty array.");
          break;
        } 
        
        auto arrayType = arr[0].GetType();
        
        if (arr.Size() > 4) {
          LOG_ERROR(logger, "Too many array members.");
          break;
        }
 
        if (arrayType == kStringType) {
          v.type = ParsedDataType::String;
          v.dimension = arr.Size();
 
          for (auto & a : arr) {
            ParsedValue p;
            p.value = a.GetString();
            v.values.push_back(p);
          }
        } else {
          v.type = (ParsedDataType)((size_t)ParsedDataType::Float + arr.Size() - 1);
          for (uint32_t i = 0; i < arr.Size(); ++i) {
            switch (arr[i].GetType())
            {
            case kNumberType:
              v.float4Value[static_cast<glm::length_t>(i)] = arr[i].GetFloat();
              break;
            default:
              LOG_ERROR(logger, "Unknown vector type.");
              break;
            }
          }
        }
      }
      break;
      case kTrueType:
        v.type = ParsedDataType::Bool;
        v.boolValue = true;
        break;
      case kFalseType:
        v.type = ParsedDataType::Bool;
        v.boolValue = false;
        break;
      default:
        break;
      }
    }
 
    void parseResource(const Value & value, RenderResourceDefinition & resource, const std::string & /*condition*/)
    {
      if (value.IsString()) {
        std::string str = value.GetString();
 
        auto space = str.find(' ');
        if (space != std::string::npos) {
          resource.type = parseResourceType(str.substr(0, space));
          resource.alias = str.substr(space + 1);
        } else {
          resource.type = parseResourceType(str);
        }
      } else if (value.IsObject()) {
        for (auto & m : value.GetObject()) {
          auto key = toKey(m.name);
 
          if (key == "type") {
            resource.type = parseResourceType(m.value.GetString());
          } else if (key == "textures") {
            for (auto & t : m.value.GetArray()) {
              resource.textures.push_back(t.GetString());
            }
          } else {
            ParsedValue p;
            parseValue(key, m.value, p);
            resource.parameters.push_back(p);
          }
        }
      }
    }
 
    bool parseResources(const Value & jsonResources, RenderPipelineDefinition & definition, const std::string & condition = "")
    {
      for (auto & m : jsonResources.GetObject()) {
        auto key = toString(m.name);
 
        if (key[0] == '$') {
          parseResources(m.value, definition, condition.size() ? condition + key : key);
          continue;
        }
 
        RenderResourceDefinition resource;
        resource.name = key;
        resource.condition = condition;
 
        parseResource(m.value, resource, condition);
 
        definition.resources.push_back(resource);
      }
 
      return true;
    }
 
    void parseSlots(const Value & value, std::vector<RenderTaskSlot> & slots)
    {
      if (value.IsArray()) {
        for (auto & v : value.GetArray()) {
          slots.push_back(toString(v));
        }
      } else if (value.IsString()) {
        slots.push_back(toString(value));
      } else if (value.IsObject()) {
        for (auto & m : value.GetObject()) {
          slots.push_back({ toString(m.name), toString(m.value) });
        }
      }
    }
 
    void parseTask(const Value & jsonTask, RenderTaskDefinition & task, const std::string & /*condition*/)
    {
      for (auto & m : jsonTask.GetObject()) {
        auto key = toString(m.name);
        auto & value = m.value;
 
        if (key == "type" && value.IsString()) {
          task.type = toString(value);
        } else if (key == "dependencies" || key == "depends") {
          if (value.IsArray()) {
            for (auto & a : value.GetArray()) {
              task.dependencies.push_back(toString(a));
            }
          } else if (value.IsString()) {
            task.dependencies.push_back(toString(value));
          }
        } else if (key == "options") {
          for (auto & m_ : value.GetObject()) {
            task.options.push_back({ toString(m_.name), toString(m_.value), {} });
          }
        } else if (key == "inputs" || key == "input") {
          parseSlots(value, task.inputs);
        } else if (key == "outputs" || key == "output") {
          parseSlots(value, task.outputs);
        } else {
          ParsedValue p;
          parseValue(key, value, p);
          task.parameters.push_back(p);
        }
      }
    }
 
    bool parseTasks(const Value & jsonTasks, RenderPipelineDefinition & definition, const std::string & condition = "")
    {
      for (auto & m : jsonTasks.GetObject()) {
        auto key = toString(m.name);
        auto & value = m.value;
 
        if (key[0] == '$') {
          parseTasks(value, definition, condition.size() ? condition + key : key);
          continue;
        }
 
        RenderTaskDefinition task;
        task.name = key;
        task.condition = condition;
 
        parseTask(value, task, condition);
 
        definition.tasks.push_back(task);
      }
 
      return true;
    }
 
    bool parseDefinition(Context * context, const Value & jsonDefinition, RenderPipelineDefinition & definition)
    {
      for (auto & m : jsonDefinition.GetObject()) {
        auto key = toString(m.name);
        auto & value = m.value;
 
        if (key == "name") {
          definition.name = toString(value);
        } else if (key == "permutations") {
          auto val = toString(value);
          loadPermutations(context, val.c_str());
        } else if (key == "options") {
          parseOptions(value, definition);
        } if (key == "resources") {
          parseResources(value, definition);
        } else if (key == "tasks") {
          parseTasks(value, definition);
        } else if (key == "generators") {
          for (auto & g : value.GetObject()) {
            RenderPipelineDefinition generator;
            generator.name = toString(g.name);
            parseDefinition(context, g.value, generator);
            definition.generators.push_back(generator);
          }
        } else if (key == "imports" || key == "import") {
          for (auto & import : value.GetObject()) {
            definition.imports.push_back({ toString(import.name), toString(import.value), {} });
          }
        } else if (key == "input" || key == "inputs") {
          parseSlots(value, definition.inputs);
        } else if (key == "outputs" || key == "output") {
          parseSlots(value, definition.outputs);
        } else if (key == "useVariables") {
          if (value.IsObject()) {
            for (auto & m_ : value.GetObject()) {
              ParsedValue p;
              auto key_ = toKey(m_.name);
              parseValue(key_, m_.value, p);
              definition.useVariables.push_back(p);
            }
          }
        } else if (key == "setVariables") {
          if (value.IsObject()) {
            for (auto & m_ : value.GetObject()) {
              ParsedValue p;
              auto key_ = toKey(m_.name);
              parseValue(key_, m_.value, p);
              definition.setVariables.push_back(p);
            }
          }
        } else if (key == "useComponentFields") {
          if (value.IsObject()) {
            for (auto & m_ : value.GetObject()) {
              ParsedValue p;
              auto key_ = toKey(m_.name);
              parseValue(key_, m_.value, p);
              definition.useComponentFields.push_back(p);
            }
          }
        }
 
      }
 
      return true;
    }
  }
}
 
Cogs::Core::RenderPipelineDefinition Cogs::Core::parsePipeline(Context * context, const StringView & resource, bool isContent)
{
  auto document = isContent ? parseJson(resource, JsonParseFlags::None) : parseJson(context, resource);
 
  if (!document.IsObject()) {
    LOG_ERROR(logger, "Cannot read pipeline from non-object JSON.");
    return RenderPipelineDefinition{};
  }
 
  for (auto & m : document.GetObject()) {
    auto key = toKey(m.name);
 
    if (key == "Pipeline") {
      RenderPipelineDefinition definition;
      parseDefinition(context, m.value, definition);
      return definition;
    }
  }
 
  return RenderPipelineDefinition{};
}