AnnotationAxisSystem.cpp

#include "AnnotationAxisSystem.h"
 
#include "Context.h"
 
#include "Systems/Core/CameraSystem.h"
#include "Systems/Core/TransformSystem.h"
 
#include "Components/Core/TextComponent.h"
 
 
void Cogs::Core::AnnotationAxisSystem::update(Context * context)
{
  const auto cameraComponent = context->cameraSystem->getMainCamera();
  const auto & cameraData = context->cameraSystem->getData(cameraComponent);
 
  for (const auto & component : pool) {
    if (!component.isActive()) continue;
 
    if (component.hasChanged()) {
      auto textComponent = component.getComponent<TextComponent>();
 
      // propagate clearing to text renderer component.
      if (component.positions.empty() || !std::isfinite(component.distance)) {
        textComponent->texts.clear();
        textComponent->positions.clear();
        textComponent->setChanged();
      }
    }
 
    if (!component.positions.empty() && std::isfinite(component.distance)) {
      auto textComponent = component.getComponent<TextComponent>();
 
      std::vector<int> indexes;
 
      // position label anchor
      if (component.viewDependentAnchor) {
        const glm::mat3 M(cameraData.viewMatrix * context->transformSystem->getLocalToWorld(component.getComponent<TransformComponent>()));
        glm::vec3 d = component.viewDependentAnchorReference * glm::inverse(M);
        float scale = glm::determinant(M);
 
        if (d.x < -0.25f * scale) {
          textComponent->horizontalJustification = HorizontalJustification::Left;
        } else if (d.x > 0.25f * scale) {
          textComponent->horizontalJustification = HorizontalJustification::Right;
        } else {
          textComponent->horizontalJustification = HorizontalJustification::None;
        }
 
        if (d.y < -0.25f * scale) {
          textComponent->verticalAlignment = VerticalAlignment::Top;
        } else if (d.y > 0.25f * scale) {
          textComponent->verticalAlignment = VerticalAlignment::Bottom;
        } else {
          textComponent->verticalAlignment = VerticalAlignment::Center;
        }
      }
 
      float distance = component.distance;
 
      addAnnotations(0,
                     indexes,
                     cameraData.viewProjection * context->transformSystem->getLocalToWorld(component.getComponent<TransformComponent>()),
                     cameraComponent->viewportSize,
                     distance,
                     component.positions.data(),
                     0,
                     static_cast<int>(component.positions.size()) - 1);
 
 
      textComponent->texts.resize(indexes.size());
      textComponent->positions.resize(indexes.size());
 
      for (size_t i = 0; i < indexes.size(); ++i) {
        textComponent->texts[i] = component.strings[indexes[i]];
        textComponent->positions[i] = component.positions[indexes[i]];
      }
 
      textComponent->positionMode = PositionMode::Local;
      textComponent->setChanged();
    }
  }
}
 
float Cogs::Core::AnnotationAxisSystem::getScreenSpaceDistance(const glm::vec3 & p1, const glm::vec3 & p2, const glm::vec2 & viewportSize) const
{
  glm::vec3 distanceVector = p2 - p1;
 
  distanceVector[0] = glm::abs(distanceVector[0]) * viewportSize[0] * 0.5f;
  distanceVector[1] = glm::abs(distanceVector[1]) * viewportSize[1] * 0.5f;
  distanceVector[2] = 0.0f;
 
  return glm::length(distanceVector);
}
 
void Cogs::Core::AnnotationAxisSystem::addAnnotations(const int level,
                                                      std::vector<int> & indexes,
                                                      const glm::mat4 & projectionMatrix,
                                                      const glm::vec2 & viewportSize,
                                                      const float limit,
                                                      const glm::vec3 * positions,
                                                      int startIndex,
                                                      int endIndex)
{
  if (startIndex == endIndex) return;
 
  int mid = (startIndex + endIndex) / 2;
 
  glm::vec3 p[3];
  p[0] = positions[startIndex];
  p[1] = positions[mid];
  p[2] = positions[endIndex];
 
  for (int i = 0; i < 3; i++) {
    glm::vec4 projected = projectionMatrix * glm::vec4(p[i], 1);
    const float wInv = 1.0f / projected.w;
    p[i] = glm::vec3(projected.x * wInv, projected.y * wInv, projected.z * wInv);
  }
 
  // Handle corner points.
  if (level == 0) {
    if (this->getScreenSpaceDistance(p[0], p[2], viewportSize) > limit) {
      indexes.push_back(startIndex);
      indexes.push_back(endIndex);
    }
  }
 
  if ((mid == startIndex) || (mid == endIndex)) return;
 
  float distance  = this->getScreenSpaceDistance(p[1], p[0], viewportSize);
  if (distance > limit) {
    indexes.push_back(mid);
  }
 
  this->addAnnotations(level + 1, indexes, projectionMatrix, viewportSize, limit, positions, startIndex, mid);
  this->addAnnotations(level + 1, indexes, projectionMatrix, viewportSize, limit, positions, mid, endIndex);
}