TensionRingComponent.cpp

#include "TensionRingComponent.h"
 
#include "Context.h"
#include "Types.h"
#include "EntityStore.h"
 
#include "Components/Geometry/VariableExtrusionComponent.h"
#include "Components/Data/TrajectoryComponent.h"
#include "Components/Core/MeshRenderComponent.h"
#include "Components/Appearance/MaterialComponent.h"
 
#include "ProfileGenerator.h"
#include "Utilities/Math.h"
 
#include "Foundation/Geometry/Glm.hpp"
#include "Foundation/Geometry/SampleListGenerator.hpp"
#include "Foundation/Geometry/PathGenerator.hpp"
 
using namespace Cogs::Reflection;
using namespace Cogs::Geometry;
 
void Cogs::Core::TensionRingComponent::registerType()
{
  Field fields [] = {
    Field(Name("startDepth"), &TensionRingComponent::startDepth),
    Field(Name("endDepth"), &TensionRingComponent::endDepth),
 
    Field(Name("innerRadius"), &TensionRingComponent::innerRadius),
    Field(Name("outerRadius"), &TensionRingComponent::outerRadius),
 
    Field(Name("splitAngle"), &TensionRingComponent::splitAngle),
    Field(Name("splitDistance"), &TensionRingComponent::splitDistance),
    Field(Name("extensionRadius"), &TensionRingComponent::extensionRadius),
 
    Field(Name("startAngle"), &TensionRingComponent::startAngle),
  };
 
  Method methods [] = {
    Method(Name("initialize"), &TensionRingComponent::initialize),
    Method(Name("update"), &TensionRingComponent::update),
  };
 
  DynamicComponent::registerDerivedType<TensionRingComponent>().setFields(fields).setMethods(methods);
}
 
void Cogs::Core::TensionRingComponent::initialize(Context * context)
{
  shape1 = context->store->createChildEntity("VariableExtrusionShape", getContainer());
  shape2 = context->store->createChildEntity("VariableExtrusionShape", getContainer());
 
  trajectory1 = context->store->createChildEntity("Trajectory", getContainer());
  trajectory2 = context->store->createChildEntity("Trajectory", getContainer());
}
 
void Cogs::Core::TensionRingComponent::update()
{
  auto variableExtrusion = getComponent<VariableExtrusionComponent>();
 
  assert(variableExtrusion && "No variable extrusion available for riser.");
 
  if (!variableExtrusion->trajectory) return;
 
  auto mainTrajectory = variableExtrusion->trajectory->getComponent<TrajectoryComponent>();
 
  if (!mainTrajectory) return;
 
  if (!this->hasChanged() && !mainTrajectory->hasChanged() && !variableExtrusion->hasChanged()) {
    if (this->getComponent<MaterialComponent>()->hasChanged()) {
      updateChildren();
    }
 
    return;
  }
 
  updateChildren();
 
  std::vector<float> trajectoryDepths;
 
  SampleListGenerator::generateIndexedSamples(startDepth, endDepth, mainTrajectory->indexes.data(), static_cast<int>(mainTrajectory->indexes.size()), trajectoryDepths);
 
  if (trajectoryDepths.size() < 2) return;
 
  if (trajectoryDepths[0] > startDepth || trajectoryDepths[trajectoryDepths.size() - 1] < endDepth) return;
 
  const float radiusScale = variableExtrusion->radiusScale;
  const glm::vec3 scaleVector(radiusScale, radiusScale, 1);
 
  auto leftTrajectory = trajectory1->getComponent<TrajectoryComponent>();
  auto rightTrajectory = trajectory2->getComponent<TrajectoryComponent>();
 
  leftTrajectory->positions.resize(trajectoryDepths.size());
  leftTrajectory->indexes.resize(trajectoryDepths.size());
 
  rightTrajectory->positions.resize(trajectoryDepths.size());
  rightTrajectory->indexes.resize(trajectoryDepths.size());
 
  auto shape1 = this->shape1->getComponent<VariableExtrusionComponent>();
  auto shape2 = this->shape2->getComponent<VariableExtrusionComponent>();
 
  std::vector<glm::vec3> positions(trajectoryDepths.size());
  std::vector<glm::vec3> directions(trajectoryDepths.size());
 
  PathGenerator::generateLinearPath(trajectoryDepths.data(),
                                    static_cast<int>(trajectoryDepths.size()),
                                    mainTrajectory->indexes.data(),
                                    mainTrajectory->positions.data(),
                                    static_cast<int>(mainTrajectory->indexes.size()),
                                    positions.data(),
                                    directions.data());
 
  for (size_t i = 0; i < trajectoryDepths.size(); ++i) {
    const glm::vec3 & trajPos = positions[i];
    const glm::vec3 & direction = directions[i];
 
    glm::vec3 offsetLeft(0, this->splitDistance, 0);
    glm::vec3 offsetRight(0, -this->splitDistance, 0);
    glm::vec3 offsetRotationAxis = directions[0];
 
    if (directions[0].z == 0.0f) {
      offsetLeft = glm::vec3(0, 0, this->splitDistance);
      offsetRight = glm::vec3(0, 0, -this->splitDistance);
    }
 
    auto offsetRotation = glm::angleAxis(splitAngle, offsetRotationAxis);
    offsetLeft = offsetRotation * offsetRotationAxis;
    offsetRight = offsetRotation * offsetRotationAxis;
 
    auto rotation = getRotation(directions[0], direction);
    offsetLeft = rotation * offsetRotationAxis;
    offsetRight = rotation * offsetRotationAxis;
 
    leftTrajectory->positions[i] = trajPos + (offsetLeft * scaleVector);
    leftTrajectory->indexes[i] = trajectoryDepths[i];
 
    rightTrajectory->positions[i] = trajPos + (offsetRight * scaleVector);
    rightTrajectory->indexes[i] = trajectoryDepths[i];
  }
 
  const float depth = this->startDepth;
 
  const float length = this->endDepth - depth;
  const float partLength = length / 3;
 
  const float innerRadius = this->innerRadius * radiusScale;
  const float outerRadius = this->outerRadius * radiusScale;
  const float extensionRadius = this->extensionRadius * radiusScale;
 
  std::vector<float> depths;
  std::vector<glm::vec2> profile;
 
  profile.push_back(glm::vec2(innerRadius, 0)); depths.push_back(depth);
  profile.push_back(glm::vec2(outerRadius, 0)); depths.push_back(depth);
  profile.push_back(glm::vec2(outerRadius, 0)); depths.push_back(depth + partLength);
  profile.push_back(glm::vec2(extensionRadius, 0)); depths.push_back(depth + partLength);
  profile.push_back(glm::vec2(extensionRadius, 0)); depths.push_back(depth + partLength * 2);
  profile.push_back(glm::vec2(outerRadius, 0)); depths.push_back(depth + partLength * 2);
  profile.push_back(glm::vec2(outerRadius, 0)); depths.push_back(depth + length);
  profile.push_back(glm::vec2(innerRadius, 0)); depths.push_back(depth + length);
  profile.push_back(glm::vec2(innerRadius, 0)); depths.push_back(depth);
 
  shape1->depths = depths;
  shape1->profile = profile;
  shape1->setChanged();
 
  shape2->depths = std::move(depths);
  shape2->profile = std::move(profile);
  shape2->setChanged();
 
  auto meshRenderComponent2 = shape2->getComponent<MeshRenderComponent>();
  meshRenderComponent2->setVisible(this->splitDistance != 0);
 
  if (this->splitDistance == 0.0f) {
    shape1->closed = variableExtrusion->closed;
    shape1->angle = startAngle;
    shape1->enableRotation = shape1->angle != 0;
  } else {
    //NOTE: Setting closed on TensionRing has no effect when split distance != 0
    // need to be able to set start and end angle in extrusion shape for this to be possible.
    shape1->closed = false;
    shape1->angle = this->splitAngle;
    shape1->enableRotation = true;
    shape2->angle = shape1->angle + glm::pi<float>();
    shape2->closed = false;
  }
}
 
void Cogs::Core::TensionRingComponent::updateChildren()
{
  const auto ves = getComponent<VariableExtrusionComponent>();
 
  const auto children = {
    shape1->getComponent<VariableExtrusionComponent>(),
    shape2->getComponent<VariableExtrusionComponent>(),
  };
 
  for (auto & c : children) {
    c->trajectory = ves->trajectory;
    c->closed = ves->closed;
  }
 
  const auto material = getComponent<MaterialComponent>();
 
  const auto materials = {
    shape1->getComponent<MaterialComponent>(),
    shape2->getComponent<MaterialComponent>(),
  };
 
  for (auto & m : materials) {
    m->diffuseColor = material->diffuseColor;
    m->setChanged();
  }
}