LocationComponent.cpp

#include "LocationComponent.h"
#include "Context.h"
#include "EntityStore.h"
#include "../Utils.h"
 
#include "Components/Core/MeshComponent.h"
#include "Components/Core/TransformComponent.h"
#include "Components/Appearance/MaterialComponent.h"
 
#include "Resources/MeshManager.h"
 
#include "../Components/DataSetComponent.h"
#include "../Components/DataRefComponent.h"
 
#include "Foundation/Logging/Logger.h"
 
namespace {
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("LocationComponent");
}
 
using glm::make_quat;
using glm::value_ptr;
 
using namespace Cogs::Core;
using namespace Cogs::Reflection;
using namespace Cogs::Core::EchoSounder;
 
void LocationComponent::registerType()
{
 
  Field fields[] = {
    Field(Name("time"), &LocationComponent::time),
    Field(Name("updateTransform"), &LocationComponent::updateTransform)
  };
  Method methods[] = {
    Method(Name("initialize"), &LocationComponent::initialize),
    Method(Name("update"), &LocationComponent::update),
  };
  DynamicComponent::registerDerivedType<LocationComponent>()
    .setFields(fields)
    .setMethods(methods);
}
 
void LocationComponent::initialize(Context * context)
{
  this->context = context;
  this->dataSystem = ExtensionRegistry::getExtensionSystem<DataSetSystem>(context);
}
 
void LocationComponent::update()
{
  if (!this->dataSystem) return;
 
  auto dataRefComp = getComponent<DataRefComponent>();
  if (dataRefComp->data) {
    auto * dataComp = dataRefComp->data->getComponent<DataSetComponent>();
    auto & dataData = dataSystem->getData(dataComp);
 
    if (hasFieldChanged(&LocationComponent::time) ||
        dataRefComp->hasChanged() ||
        dataComp->hasChanged() ||
        dataGen != dataData.dataGen)
    {
      const auto & config = dataData.persistent->config;
      const auto & buffer = dataData.persistent->buffer;
 
      dataGen = dataData.dataGen;
      if (buffer.sliceCount) {
        try {
          index = locateContainingInterval((int)buffer.sliceBegin,
                                           (int)(buffer.sliceBegin + buffer.sliceCount) - 1,
                                           config.capacity, buffer.timestamps, time);
        }
        catch (std::runtime_error e) {
          index = buffer.sliceBegin;
        }
        index = index % config.capacity;
 
        if (updateTransform) {
          auto * trComp = getComponent<TransformComponent>();
          trComp->position = buffer.metaPings[index].vesselPositionGlobal;
          trComp->rotation = buffer.metaPings[index].vesselOrientationGlobal;
          trComp->setChanged();
        }
      }
    }
  }
}