SubContext.cpp

#include "SubContext.h"
 
#include "../Systems/Core/CameraSystem.h"
 
#include "Foundation/Logging/Logger.h"
 
namespace
{
  const Cogs::Logging::Log logger = Cogs::Logging::getLogger("SubContext");
}
 
Cogs::Core::SubContext::SubContext(ExpressionContext* parent)
{
  if (parent) expressionContext.inherit(parent);
}
 
void Cogs::Core::SubContext::useVariables(Context* context, const std::vector<ParsedValue>& vars)
{
  for (const auto& p : vars) {
    switch (p.type)
    {
    case Cogs::Core::ParsedDataType::Unknown:
    case Cogs::Core::ParsedDataType::String:
    {
      auto tokens = Cogs::Core::tokenize(p.value);
      if (tokens.size() == 2) {
        auto value = std::stod(tokens[1].to_string());
        value = context->variables->get(tokens[0], value);
 
        auto& expVal = expressionContext.add(p.key, value);
        toPull.push_back({ tokens[0].to_string(), &expVal.value });
      }
      else {
        LOG_ERROR(logger, "Malformed useVariables entry: %s", p.value.c_str());
      }
      break;
    }
    case Cogs::Core::ParsedDataType::Float:
      expressionContext.add(p.key, p.floatValue);
      break;
 
    default:
      break;
    }
  }
}
 
void Cogs::Core::SubContext::setVariables(Context* /*context*/, const std::vector<ParsedValue>& vars)
{
  for (const auto& p : vars) {
    switch (p.type)
    {
    case Cogs::Core::ParsedDataType::Unknown:
    case Cogs::Core::ParsedDataType::String:
    {
      expressionContext.add(p.key, 0.0);
      auto expr = expressionContext.compile(p.value, p.key);
      if (expr) {
        expressionContext.update(expr, 0.0);
        toUpdate.push_back(expr);
      }
      break;
    }
    case Cogs::Core::ParsedDataType::Float:
      expressionContext.add(p.key, p.floatValue);
      break;
 
    default:
      break;
    }
  }
}
 
void Cogs::Core::SubContext::useComponentFields(RenderTaskContext* renderContext, const std::vector<ParsedValue>& vars)
{
  for (const auto& p : vars) {
    auto tokens = Cogs::Core::tokenize(p.value);
 
    if (tokens.size() != 2) {
      LOG_ERROR(logger, "Malformed useComponentFields entry: %s", p.value.c_str());
      continue;
    }
 
    auto& expVal = expressionContext.add(p.key, std::stod(tokens[1].to_string()));
 
    TokenStream hierarchy;
    tokens.reserve(8);
    split(tokens[0], ".", hierarchy);
 
    if (2 <= hierarchy.size() && renderContext->cameraData && renderContext->cameraData->camera) {
      const auto compHandle = renderContext->cameraData->camera.resolveComponent<Cogs::Core::CameraComponent>()->getComponentHandle(hierarchy[0]);
      if (auto* component = compHandle.resolve(); component) {
        auto& componentType = Cogs::Reflection::TypeDatabase::getType(component->getTypeId());
        auto field = componentType.getField(hierarchy[1]);
        if (field) {
 
          uint32_t index = 0;
          if (3 <= hierarchy.size()) {
            switch (hierarchy[2][0])
            {
            case 'x': case 'r': index = 0; break;
            case 'y': case 'g': index = 1; break;
            case 'z': case 'b': index = 2; break;
            case 'w': case 'a': index = 3; break;
            default:
              break;
            }
          }
 
          auto& fieldType = Cogs::Reflection::TypeDatabase::getType(field->getTypeId());
          auto hash = Cogs::StringView(fieldType.getName().c_str()).hash();
 
          size_t offset = 0;
          ParsedDataType baseType = ParsedDataType::Unknown;
 
          switch (hash)
          {
          case Cogs::hash("bool"):
            offset = field->getOffset();
            baseType = ParsedDataType::Bool;
            break;
          case Cogs::hash("uint32_t"):
            offset = field->getOffset();
            baseType = ParsedDataType::UInt;
            break;
          case Cogs::hash("uvec2"):
            offset = field->getOffset() + sizeof(uint32_t) * std::min(index, 1u);
            baseType = ParsedDataType::UInt;
            break;
          case Cogs::hash("uvec3"):
            offset = field->getOffset() + sizeof(uint32_t) * std::min(index, 2u);
            baseType = ParsedDataType::UInt;
            break;
          case Cogs::hash("uvec4"):
            offset = field->getOffset() + sizeof(uint32_t) * std::min(index, 3u);
            baseType = ParsedDataType::UInt;
            break;
          case Cogs::hash("int32_t"):
            offset = field->getOffset();
            baseType = ParsedDataType::Int;
            break;
          case Cogs::hash("ivec2"):
            offset = field->getOffset() + sizeof(int32_t) * std::min(index, 1u);
            baseType = ParsedDataType::Int;
            break;
          case Cogs::hash("ivec3"):
            offset = field->getOffset() + sizeof(int32_t) * std::min(index, 2u);
            baseType = ParsedDataType::Int;
            break;
          case Cogs::hash("ivec4"):
            offset = field->getOffset() + sizeof(int32_t) * std::min(index, 3u);
            baseType = ParsedDataType::Int;
            break;
          case Cogs::hash("float"):
            offset = field->getOffset();
            baseType = ParsedDataType::Float;
            break;
          case Cogs::hash("vec2"):
            offset = field->getOffset() + sizeof(float) * std::min(index, 1u);
            baseType = ParsedDataType::Float;
            break;
          case Cogs::hash("vec3"):
            offset = field->getOffset() + sizeof(float) * std::min(index, 2u);
            baseType = ParsedDataType::Float;
            break;
          case Cogs::hash("vec4"):
            offset = field->getOffset() + sizeof(float) * std::min(index, 3u);
            baseType = ParsedDataType::Float;
            break;
          default:
            break;
          }
          if (baseType != ParsedDataType::Unknown) {
            compFieldsToPull.push_back({ compHandle, offset, baseType, &expVal.value });
          }
          else {
            LOG_ERROR(logger, "useComponentFields: Unsupported type %s", fieldType.getName().c_str());
          }
        }
        else {
          LOG_ERROR(logger, "useComponentFields: Component %s doesn't have field %s", hierarchy[0].to_string().c_str(), hierarchy[1].to_string().c_str());
        }
      }
      else {
        LOG_ERROR(logger, "useComponentFields: couldn't find component %s in entity", hierarchy[0].to_string().c_str());
      }
    }
  }
 
}
 
 
void Cogs::Core::SubContext::pullVariables(Context* context)
{
  for (const auto& p : toPull) {
    *p.second = context->variables->get(p.first, *p.second);
  }
  for (const auto& p : compFieldsToPull) {
    if (!std::get<0>(p)) continue;
    const auto* component = std::get<0>(p).resolve();
    const auto* src = (char*)component + std::get<1>(p);
    auto* dst = std::get<3>(p);
    switch (std::get<2>(p))
    {
    case ParsedDataType::Bool: *dst = *(const bool*)src ? 1 : 0; break;
    case ParsedDataType::Int: *dst = *(const int32_t*)src; break;
    case ParsedDataType::UInt: *dst = *(const uint32_t*)src; break;
    case ParsedDataType::Float: *dst = *(const float*)src; break;
    default:
      break;
    }
  }
 
  for (auto& e : toUpdate) {
    expressionContext.update(e, 0.0);
  }
}