TrajectoryCrossSectionsSystem.cpp

#define _USE_MATH_DEFINES
#include <cmath>
 
#include "Context.h"
#include "Resources/MeshManager.h"
 
#include "Components/Core/MeshComponent.h"
#include "Components/Core/MeshRenderComponent.h"
#include "Components/Data/TrajectoryComponent.h"
#include "Components/Core/SceneComponent.h"
#include "Components/Core/LodComponent.h"
 
#include "Systems/Core/LodSystem.h"
#include "Systems/Core/CameraSystem.h"
#include "Systems/Core/TransformSystem.h"
#include "Systems/Data/TrajectorySystem.h"
 
#include "Utilities/FrustumClassification.h"
#include "Utilities/TransformVertices.h"
#include "Utilities/TessellationPredicates.h"
 
#include "LoftedCrossSectionsComponent.h"
#include "TrajectoryCrossSectionsSystem.h"
#include "LoftedCrossSectionsSystem.h"
 
#include "Foundation/ComponentModel/Entity.h"
#include "Foundation/Logging/Logger.h"
 
using namespace Cogs::Geometry;
using namespace Cogs::Core;
 
namespace {
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("TrajectoryCrossSectionSystem");
 
  template<typename Store> struct StoreTraits;
 
  template<>
  struct StoreTraits < std::vector<Cogs::Core::PositionNormalVertex> >
  {
    typedef std::vector<Cogs::Core::PositionNormalVertex> Storage;
    typedef glm::vec3 Pos;
    typedef glm::vec2 Tex;
    typedef glm::vec3 Nrm;
 
    inline static void set(Storage& V, int i, const Pos& p, const Tex& /*t*/, const Nrm& n)
    {
      V[i].position = p;
      V[i].normal = n;
    }
  };
 
  template<>
  struct StoreTraits < std::vector<Cogs::Core::PositionNormalTexVertex> >
  {
    typedef std::vector<Cogs::Core::PositionNormalTexVertex> Storage;
    typedef glm::vec3 Pos;
    typedef glm::vec2 Tex;
    typedef glm::vec3 Nrm;
 
    inline static void set(Storage& V, int i, const Pos& p, const Tex& t, const Nrm& n)
    {
      V[i].position = p;
      V[i].normal = n;
      V[i].tex = t;
    }
  };
 
  template<TrajectoryCrossSectionsComponent::Parameterization type> struct ParameterizationTraits;
 
  template<>
  struct ParameterizationTraits < TrajectoryCrossSectionsComponent::Parameterization::None >
  {
    typedef std::vector<Cogs::Core::PositionNormalVertex> Store;
 
    static StoreTraits<Store>::Tex map(float /*u*/, float /*v*/, float /*circumference*/, float /*acc_coordlen*/)
    {
      return StoreTraits<Store>::Tex(0.f);
    }
 
    static const bool doubleSeam = false;
  };
 
  template<>
  struct ParameterizationTraits < TrajectoryCrossSectionsComponent::Parameterization::UnitSquare >
  {
    typedef std::vector<Cogs::Core::PositionNormalTexVertex> Store;
 
    static StoreTraits<Store>::Tex map(float u, float v, float /*circumference*/, float /*acc_coordlen*/)
    {
      return StoreTraits<Store>::Tex(u, v);
    }
 
    static const bool doubleSeam = true;
  };
 
  template<>
  struct ParameterizationTraits < TrajectoryCrossSectionsComponent::Parameterization::CoordLengthOverCircumference >
  {
    typedef std::vector<Cogs::Core::PositionNormalTexVertex> Store;
 
    static StoreTraits<Store>::Tex map(float u, float /*v*/, float circumference, float acc_coordlen)
    {
      return StoreTraits<Store>::Tex(u, acc_coordlen / circumference);
    }
 
    static const bool doubleSeam = true;
  };
 
  template<bool hollow, bool caps, TrajectoryCrossSectionsComponent::Parameterization ParamType>
  int sampleShape(typename ParameterizationTraits<ParamType>::Store& vertices,
                  std::vector<glm::vec3>& spine,
                  const std::vector<float>& depths,
                  const std::vector<glm::vec3>& positions,
                  const std::vector<glm::quat>& orientations,
                  const std::vector<bool>& include,
                  const float inner_radius,
                  const float outer_radius,
                  const float start_depth,
                  const float end_depth,
                  const int trajectory_offset,
                  const int slices,
                  const int samples)
  {
    typedef typename ParameterizationTraits<ParamType>::Store Store;
    const bool doubleSeam = ParameterizationTraits<ParamType>::doubleSeam;
 
    std::vector<glm::vec2> profile(samples);
    for (int i = 0; i < samples; i++) {
      float t = static_cast<float>(2.0*M_PI)*(static_cast<float>(i) / static_cast<float>(samples - (doubleSeam ? 1 : 0)));
      profile[i].x = cos(t);
      profile[i].y = sin(t);
    }
 
    int actualSlices = caps ? 4 : 2;
    for (int i = 1; i + 1 < slices; i++) {
      actualSlices += include[trajectory_offset + i] ? 1 : 0;
    }
 
    float circumference = 2.f*float(M_PI)*outer_radius;
    float coord_length = 0.f;
    const int f_h = hollow ? 2 : 1;
    const int f_c = caps ? 1 : 0;
 
    vertices.resize((hollow ? 2 : 1) * samples * actualSlices);
    spine.resize(actualSlices);
 
    if (true) {
      // first slice, do lerp
      size_t o = trajectory_offset;
      float t = (start_depth - depths[o]) / (depths[o + 1] - depths[o]);
      glm::quat q = glm::mix(orientations[o], orientations[o + 1], t);
      glm::vec3 u = q*glm::vec3(1.f, 0.f, 0.f);
      glm::vec3 v = q*glm::vec3(0.f, 1.f, 0.f);
      glm::vec3 w = q*glm::vec3(0.f, 0.f, 1.f);
      glm::vec3 p = glm::mix(positions[o], positions[o + 1], t);
      spine[0] = p;
      if (caps) {
        spine[1] = p;
      }
      for (int i = 0; i < samples; i++) {
        float unit_u = static_cast<float>(i) / (samples - (doubleSeam ? 1 : 0));
        typename StoreTraits<Store>::Tex tex = ParameterizationTraits<ParamType>::map(unit_u, 0.f, circumference, 0.f);
        typename StoreTraits<Store>::Nrm n = u * profile[i].x + v * profile[i].y;
        if (caps) {
          StoreTraits<Store>::set(vertices, f_h * (samples * 0 + i) + 0, p + outer_radius*n, tex, -w);
        }
        StoreTraits<Store>::set(vertices, f_h * (samples * f_c + i) + 0, p + outer_radius*n, tex, n);
        if (hollow) {
          if (caps) {
            StoreTraits<Store>::set(vertices, f_h * (samples * 0 + i) + 1, p + inner_radius*n, tex, -w);
          }
          StoreTraits<Store>::set(vertices, f_h * (samples * f_c + i) + 1, p + inner_radius*n, tex, -n);
        }
      }
      coord_length += (1.f - t)*glm::distance(positions[o], positions[o + 1]);
    }
 
    int slice = caps ? 2 : 1;
    for (int j = 1; j < slices - 1; j++) { // intermediate slices
      int k = j + trajectory_offset;
      if (j > 1) {
        coord_length += glm::distance(positions[k - 1], positions[k]);
      }
      if (include[k]) {
        glm::vec3 u = orientations[k] * glm::vec3(1.f, 0.f, 0.f);
        glm::vec3 v = orientations[k] * glm::vec3(0.f, 1.f, 0.f);
        typename StoreTraits<Store>::Pos p = positions[k];
        float unit_v = ((depths[k] - start_depth) / (end_depth - start_depth));
 
        spine[slice] = p;
        for (int i = 0; i < samples; i++) {
          float unit_u = static_cast<float>(i) / (samples - (doubleSeam ? 1 : 0));
          typename StoreTraits<Store>::Tex tex = ParameterizationTraits<ParamType>::map(unit_u, unit_v, circumference, coord_length);
          if (hollow) {
            typename StoreTraits<Store>::Nrm n = u * profile[i].x + v * profile[i].y;
            StoreTraits<Store>::set(vertices, 2 * (samples * slice + i) + 0, p + outer_radius*n, tex, n);
            StoreTraits<Store>::set(vertices, 2 * (samples * slice + i) + 1, p + inner_radius*n, tex, -n);
          }
          else {
            typename StoreTraits<Store>::Nrm n = u * profile[i].x + v * profile[i].y;
            StoreTraits<Store>::set(vertices, samples * slice + i + 0, p + outer_radius*n, tex, n);
          }
        }
        slice++;
      }
    }
 
    if (true) {  // last slice, do lerp
      size_t o = trajectory_offset + slices - 2;
      float t = (end_depth - depths[o]) / (depths[o + 1] - depths[o]);
      glm::quat q = glm::mix(orientations[o], orientations[o + 1], t);
      glm::vec3 u = q*glm::vec3(1.f, 0.f, 0.f);
      glm::vec3 v = q*glm::vec3(0.f, 1.f, 0.f);
      glm::vec3 w = q*glm::vec3(0.f, 0.f, 1.f);
      glm::vec3 p = glm::mix(positions[o], positions[o + 1], t);
      coord_length += t*glm::distance(positions[o], positions[o + 1]);
      spine[slice + 0] = p;
      if (caps){
        spine[slice + 1] = p;
      }
      for (int i = 0; i < samples; i++) {
        float unit_u = static_cast<float>(i) / (samples - (doubleSeam ? 1 : 0));
        typename StoreTraits<Store>::Tex tex = ParameterizationTraits<ParamType>::map(unit_u, 1.f, circumference, coord_length);
        typename StoreTraits<Store>::Nrm n = u * profile[i].x + v * profile[i].y;
        StoreTraits<Store>::set(vertices, f_h * (samples * (slice + 0) + i) + 0, p + outer_radius*n, tex, n);
        if (caps) {
          StoreTraits<Store>::set(vertices, f_h * (samples * (slice + 1) + i) + 0, p + outer_radius*n, tex, w);
        }
        if (hollow) {
          StoreTraits<Store>::set(vertices, f_h * (samples * (slice + 0) + i) + 1, p + inner_radius*n, tex, -n);
          if (caps){
            StoreTraits<Store>::set(vertices, f_h * (samples * (slice + 1) + i) + 1, p + inner_radius*n, tex, w);
          }
        }
      }
    }
 
    return actualSlices;
  }
 
 
  template<TrajectoryCrossSectionsComponent::Parameterization ParamType>
  void process(const TrajectoryCrossSectionsComponent& cSectComp,
               TrajectoryCrossSectionsData& cSectData,
               TrajectoryComponent* trajComp,
               TrajectoryData& trajData,
               LoftedCrossSectionsComponent* loftComp)
  {
    typedef typename ParameterizationTraits<ParamType>::Store Store;
    Store vertices;
    std::vector<glm::vec3> spine;
 
    const bool doubleSeam = ParameterizationTraits<ParamType>::doubleSeam;
    const int samples = cSectData.samples + (doubleSeam ? 1 : 0);
    const float startMeasuredDepth = cSectData.startMeasuredDepth;
    const float stopMeasuredDepth = cSectData.stopMeasuredDepth;
    const float innerRadius = cSectComp.radiusScale * cSectComp.innerRadius;
    const float outerRadius = cSectComp.radiusScale * cSectComp.outerRadius;
    int rings = cSectData.rings;
 
    switch (cSectComp.shape) {
 
    case LoftedCrossSectionsComponent::Shape::Hollow:
      rings = sampleShape<true, true, ParamType>(vertices, spine,
                                                 trajComp->indexes, trajComp->positions, trajData.frames, trajData.lodSelection,
                                                 innerRadius, outerRadius, startMeasuredDepth, stopMeasuredDepth,
                                                 cSectData.index0, rings, samples);
 
      loftComp->set(std::move(vertices), std::move(spine), LoftedCrossSectionsComponent::Shape::Hollow, samples, rings, doubleSeam);
      break;
 
    case LoftedCrossSectionsComponent::Shape::Solid:
      rings = sampleShape<false, true, ParamType>(vertices, spine,
                                                  trajComp->indexes, trajComp->positions, trajData.frames, trajData.lodSelection,
                                                  innerRadius, outerRadius, startMeasuredDepth, stopMeasuredDepth,
                                                  cSectData.index0, rings, samples);
 
      loftComp->set(std::move(vertices), std::move(spine), LoftedCrossSectionsComponent::Shape::Solid, samples, rings, doubleSeam);
      break;
 
    case LoftedCrossSectionsComponent::Shape::Shell:
      rings = sampleShape<false, false, ParamType>(vertices, spine,
                                                   trajComp->indexes, trajComp->positions, trajData.frames, trajData.lodSelection,
                                                   innerRadius, outerRadius, startMeasuredDepth, stopMeasuredDepth,
                                                   cSectData.index0, rings, samples);
 
      loftComp->set(std::move(vertices), std::move(spine), LoftedCrossSectionsComponent::Shape::Shell, samples, rings, doubleSeam);
      break;
    }
  }
 
  void minMaxFromVertices3(Context* /*context*/,
                           float* min_v3,
                           float* max_v3,
                           const uint8_t* src,
                           const size_t src_stride,
                           const size_t /*src_bytes*/,
                           const size_t src_count)
  {
    if (src_count == 0) {
      return;
    }
 
    glm::vec3& min = *reinterpret_cast<glm::vec3*>(min_v3);
    glm::vec3& max = *reinterpret_cast<glm::vec3*>(max_v3);
 
    min = max = *reinterpret_cast<const glm::vec3*>(src);
 
    for (size_t i = 1; i < src_count; i++) {
      const glm::vec3& s = *reinterpret_cast<const glm::vec3*>(src + src_stride * i);
      min = glm::min(min, s);
      max = glm::max(max, s);
    }
  }
 
 
  inline void minMaxFromVertices(Context* context,
                                 glm::vec3& min,
                                 glm::vec3& max,
                                 const std::vector<glm::vec3>& src, 
                                 size_t offset,                     
                                 size_t count)                      
  {
    assert(offset + count <= src.size());
    minMaxFromVertices3(context, glm::value_ptr(min), glm::value_ptr(max),
                        reinterpret_cast<const uint8_t*>(src.data() + offset),
                        sizeof(glm::vec3), sizeof(glm::vec3)*(src.size() - offset), count);
  }
 
} // of anonymous namespace
 
 
void Cogs::Core::TrajectoryCrossSectionsSystem::update(Context* context)
{
  CameraComponent* camComp = context->cameraSystem->getMainCamera();
 
  for (const auto & cSectComp : pool) {
    if (!cSectComp.trajectory) {
      continue;
    }
 
    TrajectoryComponent * trajComp = cSectComp.trajectory->getComponent<TrajectoryComponent>();
    LodComponent * lodComp = cSectComp.getComponent<LodComponent>();
    LodData & lodData = context->lodSystem->getData<LodData>(lodComp);
    LoftedCrossSectionsComponent * loftComp = cSectComp.getComponent<LoftedCrossSectionsComponent>();
 
    auto& cSectData = getData(&cSectComp);
    auto& trajData = context->trajectorySystem->getData(trajComp);
 
 
    // update cross sections if required
    if (cSectComp.hasChanged() || lodComp->hasChanged() || trajComp->hasChanged()) {
 
      if (trajComp->positions.size() < 2) {
        LOG_WARNING(logger, "trajectory must have at least two samples, skipping.");
        loftComp->visibility = false;
        loftComp->setChanged();
        continue;
      }
 
      if (trajComp->positions.size() != trajComp->indexes.size()) {
        LOG_WARNING(logger, "trajectory has mismatching position and index counts, skipping.");
        loftComp->visibility = false;
        loftComp->setChanged();
        continue;
      }
 
      if (cSectComp.stopMeasuredDepth <= cSectComp.startMeasuredDepth + std::numeric_limits<float>::epsilon()) {
        LOG_WARNING(logger, "trajectory subset has illegal measured depth extent, skipping.");
        loftComp->visibility = false;
        loftComp->setChanged();
        continue;
      }
 
      // clip measured depth interval to defined range
      cSectData.startMeasuredDepth = std::max(trajComp->indexes.front(), cSectComp.startMeasuredDepth);
      cSectData.stopMeasuredDepth = std::min(trajComp->indexes.back(), cSectComp.stopMeasuredDepth);
 
      // find start and stop along trajectory
      trajComp->determineindices(cSectData.index0, cSectData.index1, cSectData.rings,
                                 cSectData.startMeasuredDepth, cSectData.stopMeasuredDepth);
 
      if (cSectData.rings < 2) {
        LOG_ERROR(logger, "Less than two slices will be produced, skipping.");
        loftComp->visibility = false;
        loftComp->setChanged();
        continue;
      }
 
      // Determine bounding box (bbox of trajectory points grown by outer radius)
      minMaxFromVertices(context,
                         cSectData.trajectoryBoundingBox.min,
                         cSectData.trajectoryBoundingBox.max,
                         trajComp->positions, cSectData.index0,
                         cSectData.rings);
      cSectData.boundingBox.min = cSectData.trajectoryBoundingBox.min - glm::vec3(cSectComp.radiusScale*cSectComp.outerRadius);
      cSectData.boundingBox.max = cSectData.trajectoryBoundingBox.max + glm::vec3(cSectComp.radiusScale*cSectComp.outerRadius);
 
      // We should recreate the cross sections. However, due to culling, this
      // does not necessarily happen this frame, so we store this information
      // in a persistent flag.
      cSectData.generate = true;
    }
 
    // --- Bounding box check ------------------------------------------------
    //glm::mat4 localToClip = worldToClip * context->transformSystem->getLocalToWorld(transComp);
    FrustumPlanes frustumCheck = frustumClassifyBoundingBox(lodData.localToClip,
                                                            cSectData.boundingBox.min,
                                                            cSectData.boundingBox.max);
    if ((frustumCheck&FrustumPlanes::InsideAllButFar) != FrustumPlanes::InsideAllButFar) {
      // we're outside the frustum, don't generate any geometry.
      if (loftComp->visibility) {
        loftComp->visibility = false;
        loftComp->setChanged();
      }
      continue;
    }
    else if (loftComp->visibility == false) {
      // we have popped inside the frustum from outside, recreate geometry
      loftComp->visibility = true;
      loftComp->setChanged();
      cSectData.generate = true;
    }
 
    // --- Level of detail check ---------------------------------------------
    if (lodComp->policy == LodPolicy::GeometricTolerance) {
 
      // --- Screen space reference point ------------------------------------
      // Find screen-space reference point that we are going to use for
      // determining screen-space radius. To avoid div-by-zero and extreme
      // tessellation, we clamp this position to the near-plane.
      bool inFrontOfNear = false;
      glm::vec4 screenReferencePoint = lodData.localToClip * glm::vec4(cSectData.trajectoryBoundingBox.min, 1.f);
      for (int i = 0; i < 8; i++) {
        glm::vec3 p((i & 1) ? cSectData.trajectoryBoundingBox.min.x : cSectData.trajectoryBoundingBox.max.x,
                    (i & 2) ? cSectData.trajectoryBoundingBox.min.y : cSectData.trajectoryBoundingBox.max.y,
                    (i & 4) ? cSectData.trajectoryBoundingBox.min.z : cSectData.trajectoryBoundingBox.max.z);
        glm::vec4 h = lodData.localToClip * glm::vec4(p, 1.f);
        if (h.z / h.w < screenReferencePoint.z / screenReferencePoint.w) {
          screenReferencePoint = h;
        }
        if (h.z < -h.w) {
          inFrontOfNear = true;
        }
      }
      if (inFrontOfNear) {
        screenReferencePoint = glm::vec4(0.f, 0.f, -1.f, 1.f);
      }
 
      // --- Find screen space radius and determine refinement level ---------
      float minSamples = 3.f;
      float maxSamples = 4.f * float(cSectComp.samples);
      float epsilon = lodComp->geometricTolerance;
      glm::vec2 rr = localSphereRadiusInScreenSpace(lodData.localToClip, lodData.clipToLocal,
                                                    screenReferencePoint,
                                                    cSectComp.radiusScale*cSectComp.outerRadius);
      float nonIntegerSamples = 0.0f;
      switch (context->lodSystem->geometricErrorKind)
      {
      case GeometricErrorKind::AreaBased:
        nonIntegerSamples = sphereSectorGeometricAreaPredicate(rr, camComp->viewportSize,
                                                               epsilon*epsilon, minSamples, maxSamples);
        break;
      case GeometricErrorKind::DistanceBased:
        nonIntegerSamples = sphereSectorGeometricDistancePredicate(rr, camComp->viewportSize,
                                                                   epsilon, minSamples, maxSamples);
        break;
      }
 
      // --- Check LoD trigger geometry recreation ---------------------------
      int samples = int(std::ceil(nonIntegerSamples));
      bool change = samples != cSectData.samples;
      if (change) {
        cSectData.samples = samples;
        cSectData.generate = true;
      }
    }
    else {
      cSectData.samples = cSectComp.samples;
    }
 
    // --- Create cross sections ---------------------------------------------
    if (cSectData.generate) {
 
      switch (cSectComp.parameterization)
      {
      case TrajectoryCrossSectionsComponent::Parameterization::None:
        process<TrajectoryCrossSectionsComponent::Parameterization::None>(cSectComp, cSectData, trajComp, trajData, loftComp);
        break;
      case TrajectoryCrossSectionsComponent::Parameterization::UnitSquare:
        process<TrajectoryCrossSectionsComponent::Parameterization::UnitSquare>(cSectComp, cSectData, trajComp, trajData, loftComp);
        break;
      case TrajectoryCrossSectionsComponent::Parameterization::CoordLengthOverCircumference:
        process<TrajectoryCrossSectionsComponent::Parameterization::CoordLengthOverCircumference>(cSectComp, cSectData, trajComp, trajData, loftComp);
        break;
      }
      cSectData.generate = false;
    }
  }
}