ScreenSizeSystem.cpp

#include "ScreenSizeSystem.h"
 
#include "Context.h"
 
#include "Components/Core/SceneComponent.h"
 
#include "Services/Variables.h"
 
#include "Systems/Core/CameraSystem.h"
#include "Systems/Core/TransformSystem.h"
#include "Systems/Core/RenderSystem.h"
 
#include "Scene/GetBounds.h"
 
#include "Utilities/Parallel.h"
 
#include "Foundation/Logging/Logger.h"
 
using namespace Cogs::Core;
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("ScreenSizeSystem");
 
  template<typename FunT>
  void ForEachEntityPreOrder(Cogs::ComponentModel::Entity* entity, FunT f)
  {
    f(entity);
 
    auto sceneComponent = entity->getComponent<SceneComponent>();
    if (sceneComponent != nullptr && sceneComponent->children.size() > 0)
    {
      for (auto & child : sceneComponent->children)
      {
        ForEachEntityPreOrder(child.get(), f);
      }
    }
  }
 
  void PredictWorldBoundingBoxes(Context* context, bool workParallel, ScreenSizeComponent const & component, ScreenSizeData& data)
  {
    auto rootTransform = component.getComponent<TransformComponent>();
    auto rootLocalToWorldInverse = glm::inverse(context->transformSystem->getLocalToWorld(rootTransform));
    auto parentLocalToWorld = rootTransform->parent
                            ? context->transformSystem->getLocalToWorld(rootTransform->parent.resolveComponent<TransformComponent>())
                            : glm::translate(glm::vec3(rootTransform->coordinates - context->transformSystem->getOrigin()));
    auto totalParentTransform = parentLocalToWorld * rootLocalToWorldInverse;
 
    data.childWorldBoundingBoxes.resize(data.children.size(), Cogs::Geometry::makeEmptyBoundingBox<Cogs::Geometry::BoundingBox>());
 
    auto entityBBoxCalculationFun = [context, &data, &totalParentTransform](size_t index)
    {
      auto entity = data.children[index];
 
      auto transformComponent = entity->getComponent<TransformComponent>();
      auto meshRenderComponent = entity->getComponent<MeshRenderComponent>();
      assert(meshRenderComponent != nullptr && "MeshRenderComponent should not be null");
 
      // The local bounds are frame old
      auto & localBounds = context->renderSystem->getLocalBounds(meshRenderComponent);
      auto parentLocalTransform = totalParentTransform * context->transformSystem->getLocalToWorld(transformComponent);
      data.childWorldBoundingBoxes[index] = Bounds::getTransformedBounds(localBounds, parentLocalTransform);
    };
 
    if (workParallel) {
      Parallel::forEach(context, data.children.size(), entityBBoxCalculationFun, "PredictWorldBoundingBoxes");
    }
    else {
      for (size_t entityIndex = 0; entityIndex < data.children.size(); ++entityIndex) {
        entityBBoxCalculationFun(entityIndex);
      }
    }
  }
 
  Cogs::Geometry::BoundingBox AccumulateBoudingBoxes(ScreenSizeData& data)
  {
    auto result = Cogs::Geometry::makeEmptyBoundingBox<Cogs::Geometry::BoundingBox>();
 
    for (auto const & bb : data.childWorldBoundingBoxes) {
      result += bb;
    }
 
    return result;
  }
 
  float CalculateProjectedSize(Context* context, ScreenSizeComponent const & component, Cogs::Geometry::BoundingBox& worldBounds)
  {
    CameraComponent* cameraComponent = nullptr;
    TransformComponent* cameraTransform = nullptr;
    if (component.camera != nullptr)
    {
      cameraComponent = component.camera->getComponent<CameraComponent>();
      cameraTransform = component.camera->getComponent<TransformComponent>();
    }
    else
    {
      cameraComponent = context->cameraSystem->getMainCamera();
      cameraTransform = context->cameraSystem->getMainCamera()->getContainer()->getComponent<TransformComponent>();
    }
 
    if (cameraComponent == nullptr || cameraTransform == nullptr)
    {
      LOG_WARNING(logger, "Unable to get camera data for entity id %zu.", component.getContainer()->getId());
      return std::numeric_limits<float>::max();
    }
 
    auto & cameraData = context->cameraSystem->getData(cameraComponent);
    auto cameraPosition = glm::vec3(context->transformSystem->getLocalToWorld(cameraTransform) * glm::vec4(0, 0, 0, 1));
    auto cameraDir = glm::normalize(glm::vec3(cameraData.inverseViewMatrix * glm::vec4(0, 0, -1, 0)));
 
    auto worldCenter = (worldBounds.max + worldBounds.min) / 2.0f;
    auto worldRadius = glm::length(worldBounds.max - worldCenter);
 
    auto cameraDistanceAlongViewDir = glm::abs(glm::dot(worldCenter - cameraPosition, cameraDir));
    auto projectedRadius = worldRadius / (cameraDistanceAlongViewDir * glm::tan(cameraData.fieldOfView / 2.0f));
    return 2 * projectedRadius;
  }
 
  glm::mat4 CalculateNewTransform(Context* context, ScreenSizeComponent const & component, ScreenSizeData& /*data*/, Cogs::Geometry::BoundingBox const & worldBounds, float desiredScale)
  {
    auto transformComponent = component.getComponent<TransformComponent>();
    auto worldCenter = (worldBounds.min + worldBounds.max) / 2.0f;
    auto coreTransform = glm::translate(glm::scale(glm::translate(worldCenter), glm::vec3(desiredScale, desiredScale, desiredScale)), -worldCenter);
    auto localTransfrom = transformComponent->parent ? glm::mat4() : glm::translate(glm::vec3(transformComponent->coordinates - context->transformSystem->getOrigin()));
    return glm::inverse(localTransfrom) * coreTransform * localTransfrom;
  }
}
 
void Cogs::Core::ScreenSizeSystem::initialize(Context * context)
{
  ComponentSystem::initialize(context);
 
  taskGroup = context->taskManager->createGroup();
}
 
void Cogs::Core::ScreenSizeSystem::update(Context* context)
{
  CpuInstrumentationScope(SCOPE_SYSTEMS, "ScreenSizeSystem::update");
 
  const bool workParallel = context->engine->workParallel();
 
  calcluateNewScales(context, workParallel);
  updateTransforms(context, workParallel);
}
 
void Cogs::Core::ScreenSizeSystem::cleanup(Context * context)
{
  if (taskGroup.isValid()) {
    context->taskManager->destroy(taskGroup);
  }
}
 
void Cogs::Core::ScreenSizeSystem::calcluateNewScales(Context* context, bool workParallel)
{
  constexpr static const float Epsilon = 1e-5f;
 
  CpuInstrumentationScope(SCOPE_SYSTEMS, "ScreenSizeSystem::calcluateNewScales");
 
  auto calcluateNewScalesParallel = [this, context, workParallel](ScreenSizeComponent const & screenSizeComponent, size_t)
  {
    auto & data = this->getData<ScreenSizeData>(&screenSizeComponent);
 
    data.children.clear();
    data.transformUpdateRequired = false;
 
    ForEachEntityPreOrder(screenSizeComponent.getContainer(), [&data](Cogs::ComponentModel::Entity* entity) {
      auto meshRenderComponent = entity->getComponent<MeshRenderComponent>();
      if (meshRenderComponent != nullptr && meshRenderComponent->isVisible())
      {
        data.children.push_back(entity);
      }
    });
 
    PredictWorldBoundingBoxes(context, workParallel, screenSizeComponent, data);
    auto worldBounds = AccumulateBoudingBoxes(data);
    auto newSize = CalculateProjectedSize(context, screenSizeComponent, worldBounds);
 
    auto currentScale = std::isfinite(data.currentSize) ? screenSizeComponent.minSize / data.currentSize : 1.0f;
    auto newScale = std::isfinite(newSize) ? screenSizeComponent.minSize / newSize : 1.0f;
 
    if (newScale + Epsilon <= 1.0f)
    {
      if(currentScale + Epsilon > 1.0f)
      {
        auto transformComponent = screenSizeComponent.getComponent<TransformComponent>();
        transformComponent->transform = {};
        transformComponent->transformFlags = 1;
        transformComponent->setChanged();
 
        data.transformUpdateRequired = true;
      }
    }
    else if(newSize != data.currentSize)
    {
      auto transformComponent = screenSizeComponent.getComponent<TransformComponent>();
      transformComponent->transform = CalculateNewTransform(context, screenSizeComponent, data, worldBounds, newScale);
      transformComponent->transformFlags = 1;
      transformComponent->setChanged();
 
      data.transformUpdateRequired = true;
    }
 
    data.currentSize = newSize;
  };
 
  if (workParallel) {
    Parallel::processComponents(context, pool, "ScreenSizeSystem::calcluateNewScalesParallel", calcluateNewScalesParallel, taskGroup);
    context->taskManager->wait(taskGroup);
  }
  else {
    Serial::processComponents(pool, calcluateNewScalesParallel);
  }
}
 
void Cogs::Core::ScreenSizeSystem::updateTransforms(Context* context, bool workParallel)
{
  CpuInstrumentationScope(SCOPE_SYSTEMS, "ScreenSizeSystem::updateTransforms");
 
  auto updateTransformsParallel = [this, context](ScreenSizeComponent const & screenSizeComponent, size_t)
  {
    auto & data = this->getData<ScreenSizeData>(&screenSizeComponent);
 
    if (!data.transformUpdateRequired)
    {
      return;
    }
 
    auto transformComponent = screenSizeComponent.getComponent<TransformComponent>();
    context->transformSystem->updateLocalTransform(*transformComponent);
 
    ForEachEntityPreOrder(screenSizeComponent.getContainer(), [context, transformComponent](Cogs::ComponentModel::Entity* /*entity*/) {
      context->transformSystem->getData<Core::TransformState>(transformComponent).cached = false;
      context->transformSystem->getData<Core::TransformState>(transformComponent).changed = true;
      context->transformSystem->updateLocalToWorldTransform(*transformComponent);
    });
  };
 
  if (workParallel) {
    Parallel::processComponents(context, pool, "ScreenSizeSystem::updateTransformsParallel", updateTransformsParallel, taskGroup);
    context->taskManager->wait(taskGroup);
  }
  else {
    Serial::processComponents(pool, updateTransformsParallel);
  }
}