RiserTensionerComponent.cpp

#include "RiserTensionerComponent.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 "Utilities/Math.h"
 
#include "Foundation/Geometry/Glm.hpp"
#include "Foundation/Geometry/SampleListGenerator.hpp"
#include "Foundation/Geometry/PathGenerator.hpp"
 
using namespace Cogs::Geometry;
using namespace Cogs::Reflection;
 
void Cogs::Core::RiserTensionerComponent::registerType()
{
  Field fields [] = {
    Field(Name("startDepth"), &RiserTensionerComponent::startDepth),
    Field(Name("endDepth"), &RiserTensionerComponent::endDepth),
 
    Field(Name("topOffset"), &RiserTensionerComponent::topOffset),
    Field(Name("bottomOffset"), &RiserTensionerComponent::bottomOffset),
 
    Field(Name("cylinderBaseLength"), &RiserTensionerComponent::cylinderBaseLength),
    Field(Name("cylinderBaseRadius"), &RiserTensionerComponent::cylinderBaseRadius),
    Field(Name("cylinderHeadLength"), &RiserTensionerComponent::cylinderHeadLength),
    Field(Name("cylinderHeadRadius"), &RiserTensionerComponent::cylinderHeadRadius),
    Field(Name("cylinderInnerRadius"), &RiserTensionerComponent::cylinderInnerRadius),
    Field(Name("cylinderLength"), &RiserTensionerComponent::cylinderLength),
    Field(Name("cylinderRadius"), &RiserTensionerComponent::cylinderRadius),
 
    Field(Name("rodLength"), &RiserTensionerComponent::rodLength),
    Field(Name("rodRadius"), &RiserTensionerComponent::rodRadius),
 
    Field(Name("rodMaterial"), &RiserTensionerComponent::rodMaterial),
  };
 
  Method methods [] = {
    Method(Name("initialize"), &RiserTensionerComponent::initialize),
    Method(Name("update"), &RiserTensionerComponent::update),
  };
 
  DynamicComponent::registerDerivedType<RiserTensionerComponent>().setFields(fields).setMethods(methods);
}
 
void Cogs::Core::RiserTensionerComponent::initialize(Context * context)
{
  innerShape = context->store->createChildEntity("VariableExtrusionShape", getContainer());
  outerShape = context->store->createChildEntity("VariableExtrusionShape", getContainer());
  trajectory = context->store->createChildEntity("Trajectory", getContainer());
 
  innerShape->getComponent<VariableExtrusionComponent>()->trajectory = trajectory;
  outerShape->getComponent<VariableExtrusionComponent>()->trajectory = trajectory;
}
 
void Cogs::Core::RiserTensionerComponent::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() && !variableExtrusion->hasChanged() && !mainTrajectory->hasChanged()) {
    if (this->getComponent<MaterialComponent>()->hasChanged()) {
      updateChildren();
    }
 
    return;
  }
 
  updateChildren();
 
  const float radiusScale = variableExtrusion->radiusScale;
  const glm::vec3 scaleVector(radiusScale, radiusScale, 1);
 
  float queryDepths [2] = {
    this->startDepth,
    this->endDepth,
  };
 
  glm::vec3 positions[2];
  glm::vec3 directions[2];
 
  PathGenerator::generateLinearPath(queryDepths,
                                    2,
                                    mainTrajectory->indexes.data(),
                                    mainTrajectory->positions.data(),
                                    static_cast<int>(mainTrajectory->indexes.size()),
                                    positions,
                                    directions);
 
  const glm::vec3 topTrajectoryPosition = positions[0];
  const glm::vec3 unscaledTopPosition = topTrajectoryPosition + this->topOffset;
 
  const glm::vec3 topPosition = topTrajectoryPosition + (this->topOffset * scaleVector);
  const glm::vec3 bottomTrajectoryPosition = positions[1];
  const glm::vec3 bottomDirection = directions[1];
 
  glm::vec3 bottomOffset = this->bottomOffset;
  const glm::quat bottomRotation = getRotation(directions[0], bottomDirection);
  bottomOffset = bottomRotation * bottomOffset;
  const glm::vec3 unscaledBottomPosition = bottomTrajectoryPosition + bottomOffset;
  const glm::vec3 bottomPosition = bottomTrajectoryPosition + (bottomOffset * scaleVector);
 
  TrajectoryComponent * trajectory = this->trajectory->getComponent<TrajectoryComponent>();
 
  auto innerShape = this->innerShape->getComponent<VariableExtrusionComponent>();
  auto outerShape = this->outerShape->getComponent<VariableExtrusionComponent>();
 
  const float unscaledTensionerLength = glm::length(unscaledTopPosition - unscaledBottomPosition);
  const float tensionerLength = glm::length(topPosition - bottomPosition);
 
  const float scaledLengthRatio = tensionerLength / unscaledTensionerLength;
 
  trajectory->positions = { topPosition, bottomPosition };
  trajectory->indexes = { 0, tensionerLength };
  trajectory->setChanged();
 
  const float cylinderRadius = this->cylinderRadius * radiusScale;
  const float cylinderInnerRadius = this->cylinderInnerRadius * radiusScale;
 
  const float cylinderBaseRadius = this->cylinderBaseRadius * radiusScale;
  const float cylinderBaseLength = this->cylinderBaseLength * scaledLengthRatio;
 
  const float cylinderLength = this->cylinderLength * scaledLengthRatio;
 
  const float cylinderHeadRadius = this->cylinderHeadRadius * radiusScale;
  const float cylinderHeadLength = this->cylinderHeadLength * scaledLengthRatio;
 
  const float cylinderHeadStart = cylinderLength - cylinderHeadLength;
 
  const float rodRadius = this->rodRadius * radiusScale;
 
  std::vector<float> depths;
  std::vector<glm::vec2> profile;
 
  std::vector<float> innerDepths;
  std::vector<glm::vec2> innerProfile;
 
  profile.push_back(glm::vec2(0, 0)); depths.push_back(0);
  profile.push_back(glm::vec2(cylinderBaseRadius, 0)); depths.push_back(0);
  profile.push_back(glm::vec2(cylinderBaseRadius, 0)); depths.push_back(cylinderBaseLength);
  profile.push_back(glm::vec2(cylinderRadius, 0)); depths.push_back(cylinderBaseLength);
 
  profile.push_back(glm::vec2(cylinderRadius, 0)); depths.push_back(cylinderHeadStart);
  profile.push_back(glm::vec2(cylinderHeadRadius, 0)); depths.push_back(cylinderHeadStart);
  profile.push_back(glm::vec2(cylinderHeadRadius, 0)); depths.push_back(cylinderLength);
  profile.push_back(glm::vec2(rodRadius, 0)); depths.push_back(cylinderLength);
 
  profile.push_back(glm::vec2(rodRadius, 0)); depths.push_back(cylinderHeadStart);
  profile.push_back(glm::vec2(cylinderInnerRadius, 0)); depths.push_back(cylinderHeadStart);
  profile.push_back(glm::vec2(cylinderInnerRadius, 0)); depths.push_back(cylinderBaseLength);
  profile.push_back(glm::vec2(0, 0)); depths.push_back(cylinderBaseLength);
 
  outerShape->depths = std::move(depths);
  outerShape->profile = std::move(profile);
  outerShape->setChanged();
 
  const float rodLength = this->rodLength * scaledLengthRatio;
  const float rodStart = std::max(tensionerLength - rodLength, cylinderBaseLength);
 
  innerProfile.push_back(glm::vec2(0, 0)); innerDepths.push_back(rodStart);
  innerProfile.push_back(glm::vec2(rodRadius, 0)); innerDepths.push_back(rodStart);
 
  innerProfile.push_back(glm::vec2(rodRadius, 0)); innerDepths.push_back(tensionerLength);
  innerProfile.push_back(glm::vec2(0, 0)); innerDepths.push_back(tensionerLength);
 
  innerShape->textureScale = glm::vec2(1.0f, 1.0f / (rodLength));
  innerShape->textureOffset = glm::vec2(0.0f, -rodStart);
 
  innerShape->depths = std::move(innerDepths);
  innerShape->profile = std::move(innerProfile);
  innerShape->setChanged();
}
 
void Cogs::Core::RiserTensionerComponent::updateChildren()
{
  const auto material = getComponent<MaterialComponent>();
  
  const auto outerMaterial = outerShape->getComponent<MaterialComponent>();
  outerMaterial->diffuseColor = material->diffuseColor;
  outerMaterial->setChanged();
}