MeshGeneratorSystem.cpp

#include "MeshGeneratorSystem.h"
 
#include "Foundation/Logging/Logger.h"
 
#include "Components/Core/MeshComponent.h"
#include "Components/Core/CameraComponent.h"
#include "Components/Core/TransformComponent.h"
#include "Components/Core/LodComponent.h"
 
#include "Systems/Core/TransformSystem.h"
#include "Systems/Core/CameraSystem.h"
#include "Systems/Core/LodSystem.h"
 
#include "Context.h"
 
#include "Utilities/TessellationPredicates.h"
 
#include "Services/Services.h"
 
#include "Generators/MeshGenerator.h"
 
using namespace Cogs::Core;
 
namespace
{
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("MeshGeneratorSystem");
}
 
void Cogs::Core::MeshGeneratorSystem::update(Context * context)
{
  auto meshGenerator = context->services->getService<MeshGenerator>();
 
  auto camComp = context->cameraSystem->getMainCamera();
  for (auto & component : pool) {
    auto & data = getData(&component);
 
    auto lodComp = component.getComponent<LodComponent>();
 
    if (lodComp && lodComp->policy == LodPolicy::GeometricTolerance) {
      const auto & lodData = context->lodSystem->getData<LodData>(lodComp);
 
      // --- Get reference position and screen space radius ------------------
      glm::vec4 screenReferencePoint = lodData.localToClip * glm::vec4(0.f, 0.f, 0.f, 1.f);
 
      float minSamples = 3.f;
      float maxSamples = 4.f * float(component.samples);
      float epsilon = lodComp->geometricTolerance;
      glm::vec2 rr = localSphereRadiusInScreenSpace(lodData.localToClip, lodData.clipToLocal,
                                                    screenReferencePoint, 1.f);
 
      // --- Determine LoD ---------------------------------------------------
      float nonIntegerSamples = 0.f;
      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;
      }
      int samples = static_cast<int>(std::ceil(nonIntegerSamples));
      if (samples == data.currentSamples && !component.hasChanged()) {
        continue;
      }
      data.currentSamples = samples;
 
    } else {
      if (!component.hasChanged() ||
          (data.currentType == component.shape &&         // Make sure that spec has really changed since creating a new mesh costs a bit.
           data.currentSamples == component.samples &&
           data.currentSize == component.size &&
           data.arcStart == component.arcStart &&
           data.arcEnd == component.arcEnd)) {
        continue;
      }
 
      data.currentSamples = component.samples;
      data.currentSize = component.size;
    }
 
    data.currentType = component.shape;
    data.arcStart = component.arcStart;
    data.arcEnd = component.arcEnd;
 
    auto meshComponent = component.getComponent<MeshComponent>();
    
    assert(meshComponent && "No mesh component found to assign generated mesh.");
 
    meshComponent->meshHandle = meshGenerator->getMesh(data.currentType, data.currentSamples, component.size, data.arcStart, data.arcEnd);
    meshComponent->setChanged();
  }
}