LodSystem.cpp

#include "LodSystem.h"
 
#include "Utilities/Parsing.h"
 
#include "Context.h"
#include "CameraSystem.h"
#include "TransformSystem.h"
#include "Services/Variables.h"
 
#include "Components/Core/TransformComponent.h"
#include "Components/Core/SceneComponent.h"
#include "Components/Core/RenderComponent.h"
#include "Components/Core/MeshComponent.h"
#include "Components/Core/SceneComponent.h"
#include "Systems/Core/RenderSystem.h"
 
#include "Foundation/ComponentModel/Entity.h"
#include "Foundation/Logging/Logger.h"
 
namespace
{
  using namespace Cogs::Core;
 
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("LodSystem");
 
 
  float getMinDistanceToBBox(Context* context, Entity* entity, const glm::vec3& refWorld)
  {
    auto minDistance = std::numeric_limits<float>::max();
    if (auto * sceneComp = entity->getComponent<SceneComponent>()) {
      for (auto & child : sceneComp->children) {
        minDistance = std::min(minDistance, getMinDistanceToBBox(context, child.get(), refWorld));
      }
    }
 
    if (auto * renderComp = entity->getComponent<MeshRenderComponent>()) {
      const auto & bbox = context->renderSystem->getWorldBounds(renderComp);
      if (bbox.min.x <= bbox.max.x) {
        auto p = glm::clamp(refWorld, bbox.min, bbox.max);
        auto l = p - refWorld;
        auto d2 = glm::dot(l, l);
        if (d2 < minDistance*minDistance) {
          minDistance = std::sqrt(d2);
        }
      }
    }
    return minDistance;
  }
 
 
}
 
namespace Cogs
{
  namespace Core
  {
    void calculateLevelOfDetail(Context * context,
                             const LodComponent & component,
                             LodData & lodData,
                             const glm::vec3 & cameraCenter,
                             const CameraData & cameraData,
                             bool cameraChanged)
    {
      auto transform = component.getComponent<TransformComponent>();
      bool transformChanged = context->transformSystem->hasChanged(transform);
 
      if (!transformChanged && !cameraChanged) return;
 
      switch (component.policy) {
      case LodPolicy::CenterDistance:
        {
          glm::vec3 center = glm::vec3(context->transformSystem->getLocalToWorld(transform) * glm::vec4(0, 0, 0, 1));
 
          const float distance = glm::clamp(glm::length(center - cameraCenter), 0.0f, std::numeric_limits<float>::max());
 
          size_t index = 0;
 
          for (size_t i = 0; i < component.thresholds.size(); ++i) {
            if (distance > component.thresholds[i]) index = i;
          }
 
          lodData.currentLodIndex = static_cast<uint8_t>(index);
        }
        break;
      case LodPolicy::GeometricTolerance:
        {
          glm::mat4 localToEye = cameraData.viewMatrix * context->transformSystem->getLocalToWorld(transform);
 
          // Determine approximate eye-space radius of local space unit sphere
          float lx2 = glm::dot(localToEye[0], localToEye[0]);
          float ly2 = glm::dot(localToEye[1], localToEye[1]);
          float lz2 = glm::dot(localToEye[2], localToEye[2]);
          float r = glm::sqrt(glm::max(glm::max(lx2, ly2), lz2));
 
          // Project two points to the screen and determine pixel distance
          glm::vec4 ah = cameraData.projectionMatrix * localToEye[3];
          glm::vec4 bh = cameraData.projectionMatrix * (localToEye[3] + glm::vec4(r, 0.f, 0.f, 0.f));
          float w = 0.5f * cameraData.viewportSize.x * glm::distance((1.f / ah.w) * glm::vec2(ah.x, ah.y), (1.f / bh.w) * glm::vec2(bh.x, bh.y));
 
          lodData.detailLevel = std::ceil(glm::pi<float>() / std::acos(1.f - component.geometricTolerance / std::max(std::numeric_limits<float>::epsilon(), w)));
        }
        break;
 
      default:
        break;
      }
    }
  }
}
 
void Cogs::Core::LodSystem::update(Context * context)
{
  geometricErrorKind = parseEnum(context->variables->get("systems.lod.geometricerrorkind", "AreaBased"), GeometricErrorKind::AreaBased);
  previousFrameStickyness = glm::clamp(context->variables->get("systems.lod.previousframestickyness", 0.1f), -0.f, -0.99f);
 
  auto camera = context->cameraSystem->getMainCamera();
  auto cameraTransform = camera->getComponent<TransformComponent>();
  const auto & cameraData = context->cameraSystem->getData(camera);
  const glm::mat4 & worldToClip = cameraData.viewProjection;
  const glm::mat4 & clipToWorld = cameraData.inverseViewProjectionMatrix;
 
  glm::vec3 cameraCenter = glm::vec3(context->transformSystem->getLocalToWorld(cameraTransform) * glm::vec4(0, 0, 0, 1));
 
  for (const auto & component : pool) {
    auto & lodData = getData<LodData>(&component);
 
    if (component.policy == LodPolicy::None) continue;
 
    auto transformComponent = component.getComponent<TransformComponent>();
 
    lodData.localToClip = worldToClip * context->transformSystem->getLocalToWorld(transformComponent);
    lodData.clipToLocal = glm::inverse(context->transformSystem->getLocalToWorld(transformComponent)) * clipToWorld;
 
    auto sceneComponent = component.getComponent<SceneComponent>();
 
    if (!sceneComponent) continue;
 
    calculateLevelOfDetail(context, component, lodData, cameraCenter, cameraData, true);
    
    if (component.policy == LodPolicy::GeometricTolerance || component.policy == LodPolicy::None) continue;
 
    lodData.previousLodIndex = lodData.currentLodIndex;
 
    const uint8_t numLevels = static_cast<uint8_t>(sceneComponent->children.size());
 
    ComponentModel::ComponentCollection<RenderComponent> renderComponents;
 
    if (component.separateHierarchies) {
      for (size_t i = 0; i < sceneComponent->children.size(); i++) {
        //updateVisibility(context, sceneComponent->children.get, i == lodData.currentLodIndex);
        auto * childSceneComp = sceneComponent->children[i]->getComponent<SceneComponent>();
        childSceneComp->visible = i == lodData.currentLodIndex;
        childSceneComp->setChanged();
      }
    }
    else {
 
      for (uint8_t i = 0; i < numLevels; ++i) {
        auto & child = sceneComponent->children[i];
 
        child->getComponents(renderComponents);
 
        for (auto & renderComponent : renderComponents) {
          renderComponent.lod.selectedLod = lodData.currentLodIndex;
          renderComponent.lod.currentLod = i;
          renderComponent.lod.numLods = numLevels;
          renderComponent.lod.lodFraction = 0;
        }
 
        const auto childSceneComponent = child->getComponent<SceneComponent>();
 
        std::function<void(SceneComponent &)> updateChildren = [&, i](const SceneComponent & component)
        {
          for (auto & child : component.children) {
            child->getComponents(renderComponents);
 
            for (auto & renderComponent : renderComponents) {
              renderComponent.lod.selectedLod = lodData.currentLodIndex;
              renderComponent.lod.currentLod = i;
              renderComponent.lod.numLods = numLevels;
              renderComponent.lod.lodFraction = 0;
            }
 
            auto childSceneComponent = child->getComponent<SceneComponent>();
 
            if (childSceneComponent) {
              updateChildren(*childSceneComponent);
            }
          }
        };
 
        updateChildren(*childSceneComponent);
      }
    }
 
  }
}