ExpressionComponent.cpp

#include "ExpressionComponent.h"
 
#include "Foundation/HashSequence.h"
#include "Foundation/Logging/Logger.h"
 
#include "Types.h"
 
#include "Context.h"
 
#include "Services/Time.h"
#include "Utilities/Parsing.h"
 
using namespace Cogs::Reflection;
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("ExpressionComponent");
}
 
void Cogs::Core::ExpressionComponent::registerType()
{
  Field fields[] = {
    Field(Name("targets"), &ExpressionComponent::targets),
    Field(Name("expressions"), &ExpressionComponent::expressions),
  };
 
  Method methods[] = {
    Method(Name("update"), &ExpressionComponent::update),
    Method(Name("initialize"), &ExpressionComponent::initialize),
    Method(Name("cleanup"), &ExpressionComponent::cleanup),
  };
 
  DynamicComponent::registerDerivedType<ExpressionComponent>().setFields(fields).setMethods(methods);
}
 
void Cogs::Core::ExpressionComponent::initialize(Context * context)
{
  this->context = context;
}
 
void Cogs::Core::ExpressionComponent::update()
{
  ec.add("t", context->time->getAnimationTime());
  ec.add("id", static_cast<double>(getContainer()->getId()));
 
  if (targets.size() != expressions.size()) {
    LOG_ERROR(logger, "Invalid field sizes (%zd, %zd)", targets.size(), expressions.size());
    return;
  }
 
  if (targets.size() < compiledExpressions.size()) {
    for (size_t i = targets.size() - 1; i < compiledExpressions.size(); ++i) {
      ec.free(compiledExpressions[i].expression);
    }
  }
 
  compiledExpressions.resize(targets.size());
 
  for (size_t i = 0; i < targets.size(); ++i) {
    auto & compiledExpression = compiledExpressions[i];
 
    if (!compiledExpression.expression || hasChanged()) {
      size_t hash = hashSequence(expressions[i], targets[i]);
 
      if (compiledExpression.expression && compiledExpression.expression->hash == hash) {
        continue;
      }
 
      if (compiledExpression.expression) {
        ec.free(compiledExpression.expression);
      }
 
      if (!expressions[i].size()) continue;
 
      ec.add(targets[i], 0);
      compiledExpression.expression = ec.compile(expressions[i], targets[i]);
 
      TokenStream tokens;
      split(targets[i], ".", tokens);
 
      if (tokens.size() == 2 || tokens.size() == 3) {
        auto & componentType = TypeDatabase::getType(tokens[0]);
 
        compiledExpression.componentHandle = getComponentHandle(componentType.getTypeId());
 
        auto field = componentType.getField(tokens[1]);
 
        if (!field) {
          LOG_ERROR(logger, "Could not find field %.*s on type %.*s", StringViewFormat(tokens[1]), StringViewFormat(tokens[0]));
          continue;
        }
 
        auto & fieldType = TypeDatabase::getType(field->getTypeId());
 
        {
          bool isValid = fieldType == TypeDatabase::getType<float>() ||
            fieldType == TypeDatabase::getType<glm::vec2>() ||
            fieldType == TypeDatabase::getType<glm::vec3>() ||
            fieldType == TypeDatabase::getType<glm::vec4>() ||
            fieldType == TypeDatabase::getType<glm::quat>();
 
          if (!isValid) {
            LOG_ERROR(logger, "Target field type %s not compatible with expression output.", fieldType.getName().c_str());
            continue;
          }
        }
 
        compiledExpression.componentId = componentType.getTypeId();
        compiledExpression.fieldId = componentType.getFieldId(field);
 
        if (tokens.size() == 3) {
          auto memberField = fieldType.getField(tokens[2]);
 
          if (!memberField) {
            LOG_ERROR(logger, "Could not find field %.*s on type %s", StringViewFormat(tokens[2]), fieldType.getName().c_str());
            continue;
          }
 
          compiledExpression.memberId = fieldType.getFieldId(memberField);
        }
      }
    }
 
    if (compiledExpression.expression &&
        compiledExpression.componentId != Reflection::NoType &&
        compiledExpression.fieldId != Reflection::NoField) {
      const double value = ec.update(compiledExpression.expression, 0.0);
 
      auto component = compiledExpression.componentHandle.resolve();
      assert(component && "Component must be valid pointer.");
 
      auto field = TypeDatabase::getType(compiledExpression.componentId).getField(compiledExpression.fieldId);
      assert(field && "Field must be valid pointer.");
 
      auto & fieldType = TypeDatabase::getType(field->getTypeId());
      auto fieldValue = field->getPtr<float>(component);
 
      if (compiledExpression.memberId != Reflection::NoType) {
        auto memberField = fieldType.getField(compiledExpression.memberId);
 
        auto memberValue = memberField->getPtr<float>(fieldValue);
        *memberValue = static_cast<float>(value);
      } else {
        *fieldValue = static_cast<float>(value);
      }
 
      component->setChanged();
    }
  }
}
 
void Cogs::Core::ExpressionComponent::cleanup(Context * /*context*/)
{
  ec.clear();
  compiledExpressions.clear();
}