RiserFlexJointComponent.cpp

#include "RiserFlexJointComponent.h"
 
#include "Context.h"
#include "Types.h"
 
#include "Components/Data/TrajectoryComponent.h"
#include "Components/Geometry/VariableExtrusionComponent.h"
 
#include "ProfileGenerator.h"
 
#include "Foundation/Geometry/SampleListGenerator.hpp"
 
using namespace Cogs::Geometry;
using namespace Cogs::Reflection;
 
void Cogs::Core::RiserFlexJointComponent::registerType()
{
  Field fields [] = {
    Field(Name("startDepth"), &RiserFlexJointComponent::startDepth),
    Field(Name("endDepth"), &RiserFlexJointComponent::endDepth),
 
    Field(Name("innerRadius"), &RiserFlexJointComponent::innerRadius),
    Field(Name("outerRadius"), &RiserFlexJointComponent::outerRadius),
 
    Field(Name("connectorLength"), &RiserFlexJointComponent::connectorLength),
    Field(Name("connectorRadius"), &RiserFlexJointComponent::connectorRadius),
 
    Field(Name("flexInnerRadius"), &RiserFlexJointComponent::flexInnerRadius),
    Field(Name("flexOuterRadius"), &RiserFlexJointComponent::flexOuterRadius),
 
    Field(Name("flexStart"), &RiserFlexJointComponent::flexStart),
    Field(Name("flexLength"), &RiserFlexJointComponent::flexLength),
 
    Field(Name("reverse"), &RiserFlexJointComponent::reverse),
  };
 
  Method methods [] = {
    Method(Name("initialize"), &RiserFlexJointComponent::initialize),
    Method(Name("update"), &RiserFlexJointComponent::update),
  };
 
  DynamicComponent::registerDerivedType<RiserFlexJointComponent>().setFields(fields).setMethods(methods);
}
 
void Cogs::Core::RiserFlexJointComponent::initialize(Context * /*context*/)
{
}
 
void Cogs::Core::RiserFlexJointComponent::update()
{
  auto variableExtrusion = getComponent<VariableExtrusionComponent>();
 
  assert(variableExtrusion && "No variable extrusion available for riser.");
 
  if (!variableExtrusion->trajectory) return;
 
  auto trajectory = variableExtrusion->trajectory->getComponent<TrajectoryComponent>();
 
  if (!trajectory) return;
 
  if (!this->hasChanged() && !variableExtrusion->hasChanged()) {
    return;
  }
 
  std::vector<float> trajectoryDepths;
 
  SampleListGenerator::generateIndexedSamples(startDepth, endDepth, trajectory->indexes.data(), static_cast<int>(trajectory->indexes.size()), trajectoryDepths);
 
  if (trajectoryDepths.size() < 2) return;
 
  if (trajectoryDepths[0] > startDepth || trajectoryDepths[trajectoryDepths.size() - 1] < endDepth) return;
 
  const float radiusScale = variableExtrusion->radiusScale;
 
  const float connectorLength = this->connectorLength * radiusScale;
  const float startConnectorEndDepth = startDepth + connectorLength;
  const float endConnectorStartDepth = endDepth - connectorLength;
 
  const float flexLocation = startDepth + this->flexStart;
  const float flexLength = this->flexLength;
  const float flexStart = flexLocation - flexLength * 0.5f;
 
  const float innerRadius = this->innerRadius;
  const float outerRadius = this->outerRadius;
  const float connectorRadius = this->connectorRadius;
 
  const float flexRadius = this->flexOuterRadius;
  const float innerFlexRadius = this->flexInnerRadius;
 
  const float flexBulgeLength = flexLength / 3;
  const float flexBulgeEnd = flexStart + flexBulgeLength;
 
  std::vector<glm::vec2> profile;
  std::vector<float> depths;
 
  if (!this->reverse) {
    ProfileGenerator::generateConnector(depths, profile, startDepth, startConnectorEndDepth, innerRadius, connectorRadius, outerRadius, startDepth);
    ProfileGenerator::insertPoints(depths, profile, outerRadius, startConnectorEndDepth, flexStart, trajectoryDepths.cbegin(), trajectoryDepths.cend());
    ProfileGenerator::generateCurvedProfile(depths, profile, flexStart, flexBulgeEnd, outerRadius, flexRadius);
 
    // Insert the protrusion of the flex shape
    profile.push_back(glm::vec2(flexRadius, flexLength)); depths.push_back(flexStart);
    profile.push_back(glm::vec2(innerFlexRadius, flexLength)); depths.push_back(flexStart);
    profile.push_back(glm::vec2((innerFlexRadius + outerRadius) / 2, 0)); depths.push_back(flexLocation + flexLength / 6);
    profile.push_back(glm::vec2(outerRadius, 0)); depths.push_back(flexLocation);
 
    ProfileGenerator::insertPoints(depths, profile, outerRadius, flexLocation, endConnectorStartDepth, trajectoryDepths.cbegin(), trajectoryDepths.cend());
    ProfileGenerator::generateConnector(depths, profile, endConnectorStartDepth, endDepth, outerRadius, connectorRadius, innerRadius, endDepth);
    ProfileGenerator::insertPointsReverse(depths, profile, innerRadius, startDepth, endDepth, trajectoryDepths.cend());
 
    profile.push_back(glm::vec2(innerRadius, 0)); depths.push_back(startDepth);
  } else {
    ProfileGenerator::generateConnector(depths, profile, startDepth, startConnectorEndDepth, innerRadius, connectorRadius, outerRadius, startDepth);
    ProfileGenerator::insertPoints(depths, profile, outerRadius, startConnectorEndDepth, flexStart, trajectoryDepths.cbegin(), trajectoryDepths.cend());
 
    profile.push_back(glm::vec2(outerRadius, 0)); depths.push_back(flexStart);
 
    profile.push_back(glm::vec2(innerFlexRadius, 0)); depths.push_back(flexStart - flexLength * 0.5f);
    profile.push_back(glm::vec2(innerFlexRadius, -flexLength)); depths.push_back(flexStart);
 
    profile.push_back(glm::vec2(flexRadius, -flexLength)); depths.push_back(flexStart);
 
    // Middle of profile
 
    profile.push_back(glm::vec2(flexRadius, flexLength)); depths.push_back(flexStart + flexLength);
 
    profile.push_back(glm::vec2(innerFlexRadius, flexLength)); depths.push_back(flexStart + flexLength);
    profile.push_back(glm::vec2(innerFlexRadius, 0)); depths.push_back(flexStart + flexLength + flexLength * 0.5f);
 
    profile.push_back(glm::vec2(outerRadius, 0)); depths.push_back(flexStart + flexLength);
 
    ProfileGenerator::generateConnector(depths, profile, endConnectorStartDepth, endDepth, outerRadius, connectorRadius, innerRadius, endDepth);
    ProfileGenerator::insertPointsReverse(depths, profile, innerRadius, startDepth, endDepth, trajectoryDepths.cend());
 
    profile.push_back(glm::vec2(innerRadius, 0)); depths.push_back(startDepth);
 
    ProfileGenerator::reverseProfile(depths, profile, startDepth, endDepth);
  }
 
  variableExtrusion->depths = std::move(depths);
  variableExtrusion->profile = std::move(profile);
 
  variableExtrusion->setChanged();
}