ProfileGenerator.cpp

#include "ProfileGenerator.h"
 
namespace Cogs
{
  namespace Geometry
  {
    namespace ProfileGenerator
    {
      void
        generateConnector(std::vector<float> & depths,
        std::vector<glm::vec2> & profile,
        const float startDepth,
        const float endDepth,
        const float startRadius,
        const float outerRadius,
        const float endRadius,
        const float depthAnchor)
      {
        profile.push_back(glm::vec2(startRadius, startDepth - depthAnchor)); depths.push_back(depthAnchor);
        profile.push_back(glm::vec2(outerRadius, startDepth - depthAnchor)); depths.push_back(depthAnchor);
 
        profile.push_back(glm::vec2(outerRadius, endDepth - depthAnchor)); depths.push_back(depthAnchor);
        profile.push_back(glm::vec2(endRadius, endDepth - depthAnchor)); depths.push_back(depthAnchor);
      }
 
      void
        generateCurvedProfile(std::vector<float> & depths,
        std::vector<glm::vec2> & profile,
        const float startDepth,
        const float endDepth,
        const float startRadius,
        const float endRadius,
        const float numSections)
      {
        float scaledOuterRadius = startRadius;
        float flexStart = startDepth;
        float flexBulgeScaleRange = endRadius - startRadius;
        float flexBulgeLength = endDepth - startDepth;
 
        for (int i = 0; i <= numSections; ++i) {
          const float increment = (float) i / (float) numSections;
          const float value = increment < 0.5 ? increment * increment * 2 : 1 - (1 - increment) * (1 - increment) * 2;
 
          profile.push_back(glm::vec2(scaledOuterRadius + flexBulgeScaleRange * value, 0)); depths.push_back(flexStart + flexBulgeLength * increment);
        }
      }
 
      void
        insertPoints(std::vector<float> & depths,
        std::vector<glm::vec2> & profile,
        const float radius,
        const float startDepth,
        const float endDepth,
        std::vector<float>::const_iterator it,
        std::vector<float>::const_iterator end)
      {
        while (it != end && *it <= startDepth) {
          ++it;
        }
 
        while (it != end && *it < endDepth) {
          profile.push_back(glm::vec2(radius, 0)); depths.push_back(*it++);
        }
      }
 
      void
        insertPointsReverse(std::vector<float> & depths,
        std::vector<glm::vec2> & profile,
        const float radius,
        const float startDepth,
        const float endDepth,
        std::vector<float>::const_iterator it)
      {
        it--;
 
        while (*it >= endDepth) {
          it--;
        }
 
        while (*it > startDepth) {
          profile.push_back(glm::vec2(radius, 0)); depths.push_back(*it--);
        }
      }
 
      void
        reverseProfile(std::vector<float> & depths, std::vector<glm::vec2> & profile, const float startDepth, const float endDepth)
      {
        for (size_t i = 0; i < profile.size(); ++i) {
          depths[i] = endDepth - (depths[i] - startDepth);
 
          // When reversing the running direction of the profile, the directional part of the offsets must be reversed.
          profile[i][1] = -profile[i][1];
        }
 
        std::reverse(depths.begin(), depths.end());
        std::reverse(profile.begin(), profile.end());
      }
    }
  }
}