DepthAxisSystem.cpp

#include "DepthAxisSystem.h"
 
#include "Context.h"
 
#include "Systems/Core/CameraSystem.h"
#include "Systems/Core/TransformSystem.h"
 
#include "Utilities/Math.h"
#include "Math/LinePlaneIntersection.h"
 
#include "Components/Core/MeshComponent.h"
#include "Components/Core/TextComponent.h"
#include "Components/Core/SubMeshRenderComponent.h"
#include "Components/Data/TrajectoryComponent.h"
#include "../Components/AnnotationAxisComponent.h"
 
#include "Resources/MeshManager.h"
#include "Resources/MaterialManager.h"
#include "Resources/FontManager.h"
#include "Resources/DefaultMaterial.h"
 
#include "Foundation/ComponentModel/Entity.h"
#include "Foundation/Geometry/BoundingBox.hpp"
#include "Foundation/Geometry/SampleListGenerator.hpp"
#include "Foundation/Geometry/PathGenerator.hpp"
 
#include <algorithm>
#include <sstream>
#include <iomanip>
 
namespace Cogs
{
  namespace Core
  {
    glm::vec3 project(const CameraData & data, const glm::vec3 & in)
    {
      auto projected = data.viewProjection * glm::vec4(in, 1);
 
      projected /= projected.w != 0.0f ? projected.w : 1.0f;
 
      return glm::vec3(projected);
    }
 
    float getWorldToScreenScale(Context * /*context*/, const CameraData & cameraData, const glm::vec3 & worldCenter, float normRadius)
    {
      // Find screen space coordinates of sphere center point and tangent
      // point.
      const auto screenCenter = project(cameraData, worldCenter) + glm::vec3(normRadius, 0, 0);
 
      const auto projectionPoint = glm::vec3(cameraData.inverseViewMatrix * glm::vec4(0, 0, 0, 1));
      const auto reverseProjectedW = cameraData.inverseViewProjectionMatrix * glm::vec4(screenCenter.x, screenCenter.y, -1, 1);
 
      const auto reverseProjected = glm::vec3(reverseProjectedW / reverseProjectedW.w);
 
      const auto centerToCamera = worldCenter - projectionPoint;
 
      if (!glm::length(centerToCamera)) return 1;
 
      const float planeDistance = glm::dot(glm::normalize(centerToCamera), worldCenter);
 
      glm::vec3 intersection;
      Cogs::Geometry::intersect(glm::normalize(centerToCamera), planeDistance, projectionPoint, glm::normalize(reverseProjected - projectionPoint), intersection);
 
      return glm::length(intersection - worldCenter);
    }
  }
}
 
void Cogs::Core::DepthAxisSystem::update(Context * context)
{
  const auto cameraComponent = context->cameraSystem->getMainCamera();
  const auto & cameraData = context->cameraSystem->getData(cameraComponent);
 
  for (auto & component : pool) {
    if (!component.isActive() || !component.trajectory ||
      component.trajectory->getComponent<TrajectoryComponent>()->positions.size() < 2) {
 
      //clean up old resources if they exist
      auto meshComponent = component.getComponent<MeshComponent>();
      if (HandleIsValid(meshComponent->meshHandle)) {
        meshComponent->meshHandle = MeshHandle::NoHandle;
        auto annotationComponent = component.getComponent<AnnotationAxisComponent>();
        annotationComponent->strings.clear();
        annotationComponent->positions.clear();
 
      }
      continue;
    }
 
    auto trajectory = component.trajectory->getComponent<TrajectoryComponent>();
    auto textComponent = component.getComponent<TextComponent>();
    auto annotation = component.getComponent<AnnotationAxisComponent>();
    auto & data = getData(&component);
 
    if (component.hasChanged() || trajectory->hasChanged()) {
      data.majorTickDepths.clear();
      data.minorTickDepths.clear();
      data.currentAxis = glm::vec3();
 
      getAnnotationTicks(component, trajectory, data.majorTickDepths, data.minorTickDepths);
 
      data.majorPositions.resize(data.majorTickDepths.size());
      data.majorDirections.resize(data.majorTickDepths.size());
 
      Cogs::Geometry::PathGenerator::generateLinearPath(data.majorTickDepths.data(),
                                                        static_cast<int>(data.majorTickDepths.size()),
                                                        trajectory->indexes.data(),
                                                        trajectory->positions.data(),
                                                        static_cast<int>(trajectory->positions.size()),
                                                        data.majorPositions.data(),
                                                        data.majorDirections.data());
 
      if (data.minorTickDepths.size()) {
        data.minorPositions.resize(data.minorTickDepths.size());
        data.minorDirections.resize(data.minorTickDepths.size());
 
        Cogs::Geometry::PathGenerator::generateLinearPath(data.minorTickDepths.data(),
                                                          static_cast<int>(data.minorTickDepths.size()),
                                                          trajectory->indexes.data(),
                                                          trajectory->positions.data(),
                                                          static_cast<int>(trajectory->positions.size()),
                                                          data.minorPositions.data(),
                                                          data.minorDirections.data());
      }
 
      if (data.majorTickDepths.size()) {
        data.majorTexts.resize(data.majorTickDepths.size());
 
        addText(component, data.majorTexts.data(), data.majorTickDepths.size(), data.majorTickDepths.data());
 
        if (component.enableMinorText && data.minorTickDepths.size()) {
          data.minorTexts.resize(data.minorTickDepths.size());
 
          if (data.minorTexts.size()) {
            addText(component, data.minorTexts.data(), data.minorTickDepths.size(), data.minorTickDepths.data());
          }
        }
 
        if (component.axis.x > 0) {
          textComponent->horizontalJustification = HorizontalJustification::Left;
        } else {
          textComponent->horizontalJustification = HorizontalJustification::Right;
        }
 
        auto meshComponent = component.getComponent<MeshComponent>();
 
        if (!HandleIsValid(meshComponent->meshHandle)) {
          meshComponent->meshHandle = context->meshManager->create();
        }
 
        auto renderComponent = component.getComponent<SubMeshRenderComponent>();
 
        if (renderComponent->materials.size() != 2) {
          renderComponent->materials.resize(2);
 
          auto majorMaterial = context->materialInstanceManager->createMaterialInstance(context->materialManager->getDefaultMaterial());
          auto minorMaterial = context->materialInstanceManager->createMaterialInstance(context->materialManager->getDefaultMaterial());
 
          majorMaterial->setPermutation("Line");
          minorMaterial->setPermutation("Line");
 
          majorMaterial->setVariant("EnableLighting", false);
          minorMaterial->setVariant("EnableLighting", false);
 
          majorMaterial->setBoolProperty(DefaultMaterial::EnableLighting, false);
          minorMaterial->setBoolProperty(DefaultMaterial::EnableLighting, false);
 
          majorMaterial->setVec4Property(DefaultMaterial::DiffuseColor, component.diffuseColor);
          minorMaterial->setVec4Property(DefaultMaterial::DiffuseColor, glm::vec4(component.diffuseColor.r, component.diffuseColor.g, component.diffuseColor.b, component.diffuseColor.a * 0.5f));
 
          renderComponent->materials[0] = majorMaterial;
          renderComponent->materials[1] = minorMaterial;
        } else {
          auto majorMaterial = renderComponent->materials[0];
          auto minorMaterial = renderComponent->materials[1];
 
          majorMaterial->setVec4Property(DefaultMaterial::DiffuseColor, component.diffuseColor);
          minorMaterial->setVec4Property(DefaultMaterial::DiffuseColor, glm::vec4(component.diffuseColor.r, component.diffuseColor.g, component.diffuseColor.b, component.diffuseColor.a * 0.5f));
        }
 
        textComponent->color = component.diffuseColor;
        if (!HandleIsValid(textComponent->fontHandle)) {
          textComponent->fontHandle = context->fontManager->getHandle(context->fontManager->DefaultRegularFont);
        }
      }
    }
 
    glm::vec3 axis = glm::vec3(cameraData.inverseViewMatrix * glm::vec4(component.axis, 0));
 
    if (!glm::all(glm::epsilonEqual(data.currentAxis, axis, 0.02f))) {
      data.currentAxis = glm::normalize(axis);
 
      glm::vec3 trajectoryAxis = data.majorDirections.size() ? data.majorDirections[0] : glm::vec3(0, 0, -1);
 
      if (component.enableMaxSize) {
        std::vector<float> majorScales(data.majorTickDepths.size());
        std::vector<float> minorScales(data.minorTickDepths.size());
 
        const float distance = component.majorDistance;
        const float invertedDistance = 1.0f / distance;
 
        const float projectedSize = component.maxSize;
        const float nsize = projectedSize / static_cast<float>(cameraComponent->viewportSize.x);
 
        auto & modelMatrix = context->transformSystem->getLocalToWorld(component.getComponent<TransformComponent>());
        std::vector<glm::vec3> positions(data.majorTickDepths.size());
 
        for (size_t j = 0; j < data.majorTickDepths.size(); ++j) {
          positions[j] = Cogs::Geometry::transform(data.majorPositions[j], modelMatrix);
        }
 
        for (size_t i = 0; i < data.majorTickDepths.size(); ++i) {
          auto scale = getWorldToScreenScale(context, cameraData, positions[i], nsize) * invertedDistance;
 
          majorScales[i] = scale;
 
          if (majorScales[i] > 1 || majorScales[i] != majorScales[i]) majorScales[i] = 1;
        }
 
        positions.resize(data.minorTickDepths.size());
 
        for (size_t j = 0; j < data.minorTickDepths.size(); ++j) {
          positions[j] = Cogs::Geometry::transform(data.minorPositions[j], modelMatrix);
        }
 
        for (size_t i = 0; i < data.minorTickDepths.size(); ++i) {
          minorScales[i] = getWorldToScreenScale(context, cameraData, positions[i], nsize) * invertedDistance;
 
          if (minorScales[i] > 1 || minorScales[i] != minorScales[i]) minorScales[i] = 1;
        }
 
        std::vector<glm::vec3> vertexes;
        std::vector<uint32_t> majorIndexes;
        std::vector<uint32_t> minorIndexes;
 
        addTicks(component, vertexes, majorIndexes, data.majorPositions, data.majorDirections, axis, trajectoryAxis, component.majorDistance, majorScales);
        addTicks(component, vertexes, minorIndexes, data.minorPositions, data.minorDirections, axis, trajectoryAxis, component.minorDistance, minorScales);
 
        auto meshComponent = component.getComponent<MeshComponent>();
        auto mesh = meshComponent->meshHandle.resolve();
 
        mesh->clear();
        mesh->setIndexes(std::vector<uint32_t>());
        mesh->setPositions(std::move(vertexes));
        mesh->addSubMesh(std::span(majorIndexes), PrimitiveType::LineList);
        mesh->addSubMesh(std::span(minorIndexes), PrimitiveType::LineList);
 
        annotation->strings.clear();
        annotation->positions.clear();
 
        addAnnotations(component, annotation, data.majorPositions, data.majorDirections, data.majorTexts, axis, trajectoryAxis, component.majorDistance, majorScales);
 
        if (component.enableMinorText) {
          addAnnotations(component, annotation, data.minorPositions, data.minorDirections, data.minorTexts, axis, trajectoryAxis, component.minorDistance, minorScales, true);
        }
      } else {
        std::vector<glm::vec3> vertexes;
        std::vector<uint32_t> majorIndexes;
        std::vector<uint32_t> minorIndexes;
 
        addTicks(component, vertexes, majorIndexes, data.majorPositions, data.majorDirections, axis, trajectoryAxis, component.majorDistance, std::vector<float>());
        addTicks(component, vertexes, minorIndexes, data.minorPositions, data.minorDirections, axis, trajectoryAxis, component.minorDistance, std::vector<float>());
 
        auto meshComponent = component.getComponent<MeshComponent>();
        auto mesh = meshComponent->meshHandle.resolve();
 
        mesh->clear();
        mesh->setIndexes(std::vector<uint32_t>());
        mesh->setPositions(std::move(vertexes));
        mesh->addSubMesh(std::span(majorIndexes), PrimitiveType::LineList);
        mesh->addSubMesh(std::span(minorIndexes), PrimitiveType::LineList);
 
        annotation->strings.clear();
        annotation->positions.clear();
 
        addAnnotations(component, annotation, data.majorPositions, data.majorDirections, data.majorTexts, axis, trajectoryAxis, component.majorDistance, std::vector<float>());
 
        if (component.enableMinorText) {
          addAnnotations(component, annotation, data.minorPositions, data.minorDirections, data.minorTexts, axis, trajectoryAxis, component.minorDistance, std::vector<float>());
        }
      }
    }
  }
}
 
namespace Cogs
{
  namespace Calculation
  {
    template<class TReal, bool ShiftStartToNearestIntervalSize>
    void calculateIntervals(TReal start, TReal end, TReal interval, std::vector<TReal> & majorIntervals)
    {
      if ((end - start) <= 0) {
        return;
      }
 
      if (ShiftStartToNearestIntervalSize) {
        float startFloor = std::floor(start / interval);
        float truncatedStart = startFloor * interval;
 
        if (truncatedStart < start) {
          truncatedStart += interval;
        }
 
        start = truncatedStart;
      }
 
      float value = start;
 
      while (value <= end) {
        majorIntervals.push_back(value);
        value += interval;
      }
    }
 
    template<class TReal>
    void calculateIntermediateIntervals(TReal start, TReal end, TReal interval, const std::vector<TReal> & majorIntervals, std::vector<TReal> & intervals, float epsilon = FLT_EPSILON)
    {
      if (!majorIntervals.size()) return;
 
      float value = majorIntervals[0] - interval;
 
      while (value >= start) {
        intervals.push_back(value);
        value -= interval;
      }
 
      for (size_t i = 0; i < majorIntervals.size() - 1; ++i) {
        value = majorIntervals[i] + interval;
 
        while (value < majorIntervals[i + 1] - epsilon) {
          intervals.push_back(value);
          value += interval;
        }
      }
 
      value = majorIntervals[majorIntervals.size() - 1] + interval;
 
      while (value <= end) {
        intervals.push_back(value);
        value += interval;
      }
    }
  }
}
 
void Cogs::Core::DepthAxisSystem::getAnnotationTicks(DepthAxisComponent & component, const TrajectoryComponent * trajectory, std::vector<float> & majorTicks, std::vector<float> & minorTicks)
{
  const float scaledMajorInterval = component.majorInterval / component.unitScale;
  const float scaledMinorInterval = component.minorInterval / component.unitScale;
 
  const bool endpointsInclusive = component.endpointsInclusive;
  const bool endpointsOnly = false;
 
  const float startDepth = std::max(component.startMeasuredDepth, trajectory->indexes[0]);
  const float endDepth = std::min(component.endMeasuredDepth, trajectory->indexes[trajectory->indexes.size() - 1]);
 
  if (endpointsInclusive && (fmod(startDepth, scaledMajorInterval) != 0 || endpointsOnly)) {
    majorTicks.push_back(startDepth);
  }
 
  if (!endpointsOnly) {
    Cogs::Calculation::calculateIntervals<float, true>(startDepth, endDepth, scaledMajorInterval, majorTicks);
  }
 
  if (endpointsInclusive) {
    majorTicks.push_back(endDepth);
  }
 
  if (!endpointsOnly) {
    Cogs::Calculation::calculateIntermediateIntervals(startDepth, endDepth, scaledMinorInterval, majorTicks, minorTicks, scaledMinorInterval / 2);
  }
}
 
void Cogs::Core::DepthAxisSystem::addText(DepthAxisComponent & component, std::string * texts, const size_t count, const float * depths)
{
  const std::string & unit = component.unitOfMeasurement;
  const float unitScale = component.unitScale;
 
  for (size_t i = 0; i < count; ++i) {
    const float depth = depths[i] * unitScale;
    const float remainder = depth - std::floor(depth + 0.5f);
 
    std::stringstream ss;
 
    if (fabs(remainder) > 0.01f) {
      ss << std::fixed << std::setprecision(2) << depth << unit;
      texts[i] = ss.str();
    } else {
      ss << std::fixed << std::setprecision(0) << depth << unit;
      texts[i] = ss.str();
    }
  }
}
 
void Cogs::Core::DepthAxisSystem::addTicks(DepthAxisComponent & component, std::vector<glm::vec3> & vertexes, std::vector<uint32_t> & indexes, const std::vector<glm::vec3> & positions, const std::vector<glm::vec3> & directions, const glm::vec3 & axis, const glm::vec3 & principalAxis, const float extent, const std::vector<float> & scales)
{
  const size_t offset = vertexes.size();
 
  vertexes.resize(offset + positions.size() * 2);
  indexes.resize(positions.size() * 2);
 
  float radius = component.radius;
  bool useTrajectoryOrientedAxis = component.useTrajectoryOrientedAxis;
 
  for (size_t i = 0; i < positions.size(); ++i) {
    glm::vec3 base;
 
    glm::quat rotation = Cogs::Core::getRotation(principalAxis, directions[i]);
    base = glm::normalize(rotation * axis);
 
    glm::vec3 start = positions[i] + (base * radius);
 
    float scale = extent;
 
    if (scales.size()) {
      scale *= scales[i];
    }
 
    vertexes[offset + i * 2] = start;
    vertexes[offset + i * 2 + 1] = start + (useTrajectoryOrientedAxis ? base : axis) * 0.9f * scale;
  }
 
  // We generate indices for the line set simply by treating the vertex array as pairs of vertices making up a tick.
  int idx = 0;
  for (size_t i = 0; i < positions.size(); i++) {
    indexes[idx++] = static_cast<uint32_t>(offset + i * 2);
    indexes[idx++] = static_cast<uint32_t>(offset + i * 2 + 1);
  }
}
 
void Cogs::Core::DepthAxisSystem::addAnnotations(DepthAxisComponent & component, AnnotationAxisComponent * annotationAxis, const std::vector<glm::vec3> & positions, const std::vector<glm::vec3> & directions, const std::vector<std::string> & texts, const glm::vec3 & axis, const glm::vec3 & principalAxis, const float extent, const std::vector<float> & scales, bool removeDistantAnnotations /*= false*/)
{
  const size_t numAnnotations = positions.size();
  const size_t offset = annotationAxis->strings.size();
 
  // Make sure we have enough allocated memory for annotations.
  annotationAxis->strings.resize(offset + numAnnotations);
  annotationAxis->positions.resize(offset + numAnnotations);
 
  float radius = component.radius;
  float scaleThreshold = component.minorScaleThreshold;
  bool useTrajectoryOrientedAxis = component.useTrajectoryOrientedAxis;
 
  size_t index = offset;
 
  for (size_t i = 0; i < numAnnotations; ++i) {
    float distance = extent;
 
    if (scales.size()) {
      float scale = scales[i];
 
      // Drop annotations that have too high scale.
      if (removeDistantAnnotations && scale > scaleThreshold) {
        continue;
      }
 
      distance *= scale;
    }
 
    glm::vec3 base;
 
    glm::quat rotation = Cogs::Core::getRotation(principalAxis, directions[i]);
    base = rotation * axis;
 
    glm::vec3 start = positions[i] + (base * radius);
 
    annotationAxis->strings[index] = texts[i];
    annotationAxis->positions[index++] = start + (useTrajectoryOrientedAxis ? base : axis) * distance;
  }
 
  // Since we might have dropped some annotations, we need to make sure the arrays are correctly sized.
  annotationAxis->strings.resize(index);
  annotationAxis->positions.resize(index);
 
  annotationAxis->setChanged();
}