RiserTelescopicJointComponent.cpp

#include "RiserTelescopicJointComponent.h"
 
#include "Context.h"
#include "Types.h"
#include "EntityStore.h"
 
#include "Components/Data/TrajectoryComponent.h"
#include "Components/Geometry/VariableExtrusionComponent.h"
#include "Components/Appearance/MaterialComponent.h"
 
#include "ProfileGenerator.h"
 
#include "Foundation/Geometry/SampleListGenerator.hpp"
 
using namespace Cogs::Geometry;
using namespace Cogs::Reflection;
 
void Cogs::Core::RiserTelescopicJointComponent::registerType()
{
  Field fields [] = {
    Field(Name("startDepth"), &RiserTelescopicJointComponent::startDepth),
    Field(Name("endDepth"), &RiserTelescopicJointComponent::endDepth),
 
    Field(Name("reverse"), &RiserTelescopicJointComponent::reverse),
 
    Field(Name("connectorLength"), &RiserTelescopicJointComponent::connectorLength),
    Field(Name("connectorRadius"), &RiserTelescopicJointComponent::connectorRadius),
 
    Field(Name("topLength"), &RiserTelescopicJointComponent::topLength),
    Field(Name("armLength"), &RiserTelescopicJointComponent::armLength),
    Field(Name("cylinderLength"), &RiserTelescopicJointComponent::cylinderLength),
 
    Field(Name("armInnerRadius"), &RiserTelescopicJointComponent::armInnerRadius),
    Field(Name("armOuterRadius"), &RiserTelescopicJointComponent::armOuterRadius),
 
    Field(Name("cylinderOuterRadius"), &RiserTelescopicJointComponent::cylinderOuterRadius),
    Field(Name("innerCylinderLength"), &RiserTelescopicJointComponent::innerCylinderLength),
 
    Field(Name("pistonRadius"), &RiserTelescopicJointComponent::pistonRadius),
    Field(Name("pistonLength"), &RiserTelescopicJointComponent::pistonLength),
 
    Field(Name("armColor"), &RiserTelescopicJointComponent::armColor),
  };
 
  Method methods [] = {
    Method(Name("initialize"), &RiserTelescopicJointComponent::initialize),
    Method(Name("update"), &RiserTelescopicJointComponent::update),
  };
 
  DynamicComponent::registerDerivedType<RiserTelescopicJointComponent>().setFields(fields).setMethods(methods);
}
 
void Cogs::Core::RiserTelescopicJointComponent::initialize(Context * context)
{
  body = context->store->createChildEntity("VariableExtrusionShape", getContainer());
  arm = context->store->createChildEntity("VariableExtrusionShape", getContainer());
  top = context->store->createChildEntity("VariableExtrusionShape", getContainer());
}
 
void Cogs::Core::RiserTelescopicJointComponent::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()) {
    if (this->getComponent<MaterialComponent>()->hasChanged()) {
      updateChildren();
    }
 
    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;
  
  updateChildren();
 
  updateBody(trajectoryDepths);
  updateArm(trajectoryDepths);
  updateTop(trajectoryDepths);
}
 
void Cogs::Core::RiserTelescopicJointComponent::updateArm(const std::vector<float> & trajectoryDepths)
{
  auto variableExtrusion = arm->getComponent<VariableExtrusionComponent>();
 
  std::vector<glm::vec2> profile;
  std::vector<float> depths;
 
  const float startDepth = this->startDepth + this->topLength;
  const float endDepth = startDepth + this->armLength;
  const float pistonLength = this->pistonLength * variableExtrusion->radiusScale;
 
  const float innerRadius = this->armInnerRadius;
  const float outerRadius = this->armOuterRadius;
  const float bodyInnerRadius = this->pistonRadius;
 
  profile.push_back(glm::vec2(innerRadius, 0)); depths.push_back(startDepth);
  profile.push_back(glm::vec2(outerRadius, 0)); depths.push_back(startDepth);
 
  ProfileGenerator::insertPoints(depths, profile, outerRadius, startDepth, endDepth - pistonLength, trajectoryDepths.cbegin(), trajectoryDepths.cend());
  ProfileGenerator::generateConnector(depths, profile, endDepth - pistonLength, endDepth, outerRadius, bodyInnerRadius, innerRadius, endDepth);
  ProfileGenerator::insertPointsReverse(depths, profile, innerRadius, startDepth, endDepth, trajectoryDepths.cend());
 
  profile.push_back(glm::vec2(innerRadius, 0)); depths.push_back(startDepth);
 
  if (this->reverse) {
    ProfileGenerator::reverseProfile(depths, profile, this->startDepth, this->endDepth);
  }
 
  variableExtrusion->depths = std::move(depths);
  variableExtrusion->profile = std::move(profile);
 
  variableExtrusion->setChanged();
 
  auto material = arm->getComponent<MaterialComponent>();
 
  material->diffuseColor = armColor;
  material->setChanged();
}
 
void Cogs::Core::RiserTelescopicJointComponent::updateTop(const std::vector<float> & trajectoryDepths)
{
  auto variableExtrusion = top->getComponent<VariableExtrusionComponent>();
 
  std::vector<glm::vec2> profile;
  std::vector<float> depths;
 
  const float startDepth = this->startDepth;
  const float endDepth = startDepth + this->topLength;
 
  const float connectorLength = this->connectorLength * variableExtrusion->radiusScale;
 
  const float innerRadius = this->armInnerRadius;
  const float outerRadius = this->armOuterRadius;
  const float connectorRadius = this->connectorRadius;
 
  ProfileGenerator::generateConnector(depths, profile, startDepth, startDepth + connectorLength, innerRadius, connectorRadius, outerRadius, startDepth);
  ProfileGenerator::insertPoints(depths, profile, outerRadius, startDepth + connectorLength, endDepth, trajectoryDepths.cbegin(), trajectoryDepths.cend());
 
  profile.push_back(glm::vec2(outerRadius, 0)); depths.push_back(endDepth);
  profile.push_back(glm::vec2(innerRadius, 0)); depths.push_back(endDepth);
  profile.push_back(glm::vec2(innerRadius, 0)); depths.push_back(startDepth);
 
  if (this->reverse) {
    ProfileGenerator::reverseProfile(depths, profile, this->startDepth, this->endDepth);
  }
 
  variableExtrusion->depths = std::move(depths);
  variableExtrusion->profile = std::move(profile);
 
  variableExtrusion->setChanged();
}
 
void Cogs::Core::RiserTelescopicJointComponent::updateBody(const std::vector<float> & trajectoryDepths)
{
  auto variableExtrusion = body->getComponent<VariableExtrusionComponent>();
 
  std::vector<glm::vec2> profile;
  std::vector<float> depths;
 
  const float endDepth = this->endDepth;
  const float startDepth = endDepth - this->cylinderLength;
 
  const float connectorLength = this->connectorLength * variableExtrusion->radiusScale;
  const float connectorRadius = this->connectorRadius;
 
  const float riserInnerRadius = this->armInnerRadius;
  const float innerInnerRadius = this->armOuterRadius;
  const float innerRadius = this->pistonRadius;
  const float outerRadius = this->cylinderOuterRadius;
  const float innerCylinderLength = this->innerCylinderLength;
 
  ProfileGenerator::generateConnector(depths, profile, startDepth, startDepth + connectorLength, innerInnerRadius, connectorRadius, outerRadius, startDepth);
  ProfileGenerator::insertPoints(depths, profile, outerRadius, startDepth + connectorLength, endDepth - connectorLength, trajectoryDepths.cbegin(), trajectoryDepths.cend());
  ProfileGenerator::generateConnector(depths, profile, endDepth - connectorLength, endDepth, outerRadius, connectorRadius, riserInnerRadius, endDepth);
 
  profile.push_back(glm::vec2(riserInnerRadius, 0)); depths.push_back(startDepth + innerCylinderLength);
  profile.push_back(glm::vec2(innerRadius, 0)); depths.push_back(startDepth + innerCylinderLength);
 
  ProfileGenerator::insertPointsReverse(depths, profile, innerRadius, startDepth + connectorLength, startDepth + innerCylinderLength, trajectoryDepths.cend());
 
  profile.push_back(glm::vec2(innerRadius, 0)); depths.push_back(startDepth + connectorLength);
  profile.push_back(glm::vec2(innerInnerRadius, 0)); depths.push_back(startDepth + connectorLength);
  profile.push_back(glm::vec2(innerInnerRadius, 0)); depths.push_back(startDepth);
 
  if (this->reverse) {
    ProfileGenerator::reverseProfile(depths, profile, this->startDepth, this->endDepth);
  }
 
  variableExtrusion->depths = std::move(depths);
  variableExtrusion->profile = std::move(profile);
 
  variableExtrusion->setChanged();
}
 
void Cogs::Core::RiserTelescopicJointComponent::updateChildren()
{
  const auto ves = getComponent<VariableExtrusionComponent>();
 
  const auto children = {
    arm->getComponent<VariableExtrusionComponent>(),
    body->getComponent<VariableExtrusionComponent>(),
    top->getComponent<VariableExtrusionComponent>()
  };
 
  for (auto & c : children) {
    c->trajectory = ves->trajectory;
    c->closed = ves->closed;
    c->radiusScale = ves->radiusScale;
  }
 
  const auto material = getComponent<MaterialComponent>();
 
  const auto materials = {
    body->getComponent<MaterialComponent>(),
    top->getComponent<MaterialComponent>(),
  };
 
  for (auto & m : materials) {
    m->diffuseColor = material->diffuseColor;
    m->setChanged();
  }
}