TrajectoryAlignedComponent.cpp

#include "TrajectoryAlignedComponent.h"
 
#include "Components/Core/TransformComponent.h"
#include "Components/Data/TrajectoryComponent.h"
 
#include "Utilities/Math.h"
 
#include "Types.h"
 
#include "Foundation/Geometry/BoundingBox.hpp"
#include "Foundation/Geometry/SampleListGenerator.hpp"
#include "Foundation/Geometry/PathGenerator.hpp"
 
#include <algorithm>
 
using namespace Cogs::Reflection;
using namespace Cogs::Geometry;
 
void Cogs::Core::TrajectoryAlignedComponent::registerType()
{
  Field fields [] = {
    Field(Name("trajectory"), &TrajectoryAlignedComponent::trajectory),
    Field(Name("depth"), &TrajectoryAlignedComponent::depth),
    Field(Name("rotation"), &TrajectoryAlignedComponent::rotation),
  };
 
  Method methods [] = {
    Method(Name("update"), &TrajectoryAlignedComponent::update),
  };
 
  DynamicComponent::registerDerivedType<TrajectoryAlignedComponent>().setFields(fields).setMethods(methods);
}
 
void Cogs::Core::TrajectoryAlignedComponent::update()
{
  if (!trajectory) return;
 
  const TrajectoryComponent* trajectoryComponent = trajectory->getComponent<TrajectoryComponent>();
 
  if (!trajectoryComponent) return;
 
  std::vector<float> depths;
 
  SampleListGenerator::generateIndexedSamples(
    depth,
    depth + 1.0f,
    trajectoryComponent->indexes.data(),
    static_cast<int>(trajectoryComponent->indexes.size()),
    depths);
 
  if (!depths.size()) return;
 
  // We only need one depth, but two is the minimum for generating path/direction info.
  depths.resize(2);
 
  glm::vec3 position[2];
  glm::vec3 direction[2];
 
  PathGenerator::generateLinearPath(depths.data(),
                                    static_cast<int>(depths.size()),
                                    trajectoryComponent->indexes.data(),
                                    trajectoryComponent->positions.data(),
                                    static_cast<int>(trajectoryComponent->indexes.size()),
                                    position,
                                    direction);
 
  TransformComponent* transformComponent = getComponent<TransformComponent>();
 
  glm::vec3 newPosition = position[0] + offset;
  glm::quat newRotation = getRotation(glm::vec3(0, 0, -1), direction[0]) * rotation;
  if (transformComponent->position != newPosition || transformComponent->rotation != newRotation) {
    transformComponent->position = newPosition;
    transformComponent->rotation = newRotation;
    transformComponent->setChanged();
  }
}