SwathIsoSystem.cpp

#include "SwathIsoSystem.h"
 
#include "Context.h"
#include "EntityStore.h"
#include "Components/Core/SubMeshRenderComponent.h"
#include "Components/Core/SceneComponent.h"
#include "Components/Appearance/MaterialComponent.h"
#include "Systems/Core/TransformSystem.h"
#include "Resources/MeshManager.h"
#include "Resources/MaterialManager.h"
#include "Services/TaskManager.h"
 
#include "../Components/DataSetComponent.h"
#include "../Components/WindowComponent.h"
#include "../Components/BeamGroupComponent.h"
#include "../Components/DataRefComponent.h"
#include "../Systems/DataSetSystem.h"
 
#include "Foundation/Logging/Logger.h"
 
using Cogs::Core::Context;
using namespace Cogs::Core::EchoSounder;
 
#include "../Tasks/SwathIsoSurfacesBuildMeshTask.h"
 
void SwathIsoSystem::initialize(Context * context)
{
  ComponentSystemWithDataPool::initialize(context);
 
  surfaceMaterial = context->materialManager->loadMaterial("MultibeamIsoMaterial.material");
 
  context->materialManager->processLoading();
 
  rangeKey = surfaceMaterial->getVec4Key("range");
}
 
void SwathIsoSystem::cleanup(Context* /*context*/)
{
  surfaceMaterial = {};
}
 
void SwathIsoSystem::update(Context * context)
{
  bool activateMeshes = false;
  for (auto & isoComp : pool) {
    auto & isoData = getData(&isoComp);
 
    const auto * winComp = isoComp.getComponent<WindowComponent>();
    const auto * groupComp = isoComp.getComponent<BeamGroupComponent>();
 
    if (!winComp || !groupComp || !groupComp->sane || groupComp->majorCount != 1) {
      isoComp.setChanged();
      continue;
    }
 
    // beamGroup->sane makes sure that we have data (and that it is sane).
    const auto * dataRefComp = isoComp.getComponent<DataRefComponent>();
    const auto * dataComp = dataRefComp->data->getComponent<DataSetComponent>();
    const auto & dataData = dataSetSystem->getData(dataComp);
 
    if (isoComp.hasChanged()) {
 
      const auto layers = isoComp.thresholds.size();
      isoComp.material->setVec4Property(rangeKey, glm::vec4(isoComp.uTextureRange.x,
                                                            1.f / std::max(std::numeric_limits<float>::min(), isoComp.uTextureRange.y - isoComp.uTextureRange.x),
                                                            isoComp.vTextureRange.x,
                                                            1.f / std::max(std::numeric_limits<float>::min(), isoComp.vTextureRange.y - isoComp.vTextureRange.x)));
 
      const size_t o = isoData.layerMaterialInstances.size();
      isoData.layerMaterialInstances.resize(layers);
      for (size_t i = 0; i < layers; i++) {
        if (o <= i) {
          isoData.layerMaterialInstances[i] = context->materialInstanceManager->createMaterialInstance(surfaceMaterial);
        }
 
        isoData.layerMaterialInstances[i]->clone(isoComp.material.resolve());
        if (isoComp.innerLayerOpaque && ((i + 1) == layers)) {
          isoData.layerMaterialInstances[i]->setOpaque();
        }
        else {
          isoData.layerMaterialInstances[i]->setTransparent();
        }
        if (isoComp.layerDepthBiasStep != 0.f) {
          isoData.layerMaterialInstances[i]->options.depthBiasEnabled = true;
          isoData.layerMaterialInstances[i]->options.depthBias.slope = 0.f;
          isoData.layerMaterialInstances[i]->options.depthBias.constant = i*isoComp.layerDepthBiasStep;
          isoData.layerMaterialInstances[i]->options.depthBias.clamp = 100000.f;
        }
      }
    }
 
    bool updateParams = isoData.thresholds != isoComp.thresholds ||
      (isoData.capSeparation != isoComp.capSeparation) ||
      (isoData.flipOrientation != isoComp.flipOrientation) ||
      (isoData.innerLayerOpaque != isoComp.innerLayerOpaque) ||
      (isoData.seabedClipOffset != isoComp.seabedClipOffset) ||
      ((isoData.overflowThreshold != isoComp.overflowThreshold) && !(std::isnan(isoData.overflowThreshold) && std::isnan(isoComp.overflowThreshold))) ||
      ((isoData.minVerticalDepth != isoComp.minVerticalDepth) && !(std::isnan(isoData.minVerticalDepth) && std::isnan(isoComp.minVerticalDepth))) ||
      ((isoData.maxVerticalDepth != isoComp.maxVerticalDepth) && !(std::isnan(isoData.maxVerticalDepth) && std::isnan(isoComp.maxVerticalDepth))) ||
      (isoData.beamGroupGen != groupComp->gen) ||
      (isoData.beamSpacing != winComp->beamSpacing) ||
      (isoData.depthSpacing != winComp->depthSpacing);
 
    if (isoData.pathSpacing != winComp->pathSpacing)
    {
      //clears old data immediately, view will be empty until new data is ready
      isoData.pathSpacing = winComp->pathSpacing;
      isoData.resamplingPositions.clear(isoData.pathSpacing, context->variables->get("echo.maxPathUpsample")->getFloat());
      isoData.chunks.clear();
      isoData.meshManager.clear();
      updateParams = true;
    }
    if (updateParams)
    {
      //keeps old data until new data is ready
      isoData.thresholds = isoComp.thresholds;
      isoData.capSeparation = isoComp.capSeparation;
      isoData.flipOrientation = isoComp.flipOrientation;
      isoData.innerLayerOpaque = isoComp.innerLayerOpaque;
      isoData.seabedClipOffset = isoComp.seabedClipOffset;
      isoData.overflowThreshold = isoComp.overflowThreshold;
      isoData.minVerticalDepth = isoComp.minVerticalDepth;
      isoData.maxVerticalDepth = isoComp.maxVerticalDepth;
      isoData.beamSpacing = winComp->beamSpacing;
      isoData.depthSpacing = winComp->depthSpacing;
      isoData.beamGroupGen = groupComp->gen;
      isoData.meshManager.updateCurrent();
      isoData.runMeshManager = true;
    }
 
    bool resampleSitesChanged;
    const auto * sceneComp = isoComp.getComponent<SceneComponent>();
    if (sceneComp->visible) {
      resampleSitesChanged = isoData.resamplingPositions.update(winComp, dataComp, &dataData);
    }
    else {
      resampleSitesChanged = isoData.resamplingPositions.clear(isoData.pathSpacing, context->variables->get("echo.maxPathUpsample")->getFloat());
    }
    if (resampleSitesChanged) {
      if (isoData.chunks.update(isoData.resamplingPositions)) {
        isoData.runMeshManager = true;
      }
    }
 
    if (isoData.meshManager.ready() && isoData.runMeshManager) {
      auto * containerPtr = isoComp.getContainer();
 
 
      SwathPathMeshManager::CreateBuildFunc createBuildFunc =
        [context, groupComp, &isoComp, &isoData, &dataData](MeshHandle& mesh, uint32_t chunkIndex) -> TaskFunction
      {
        return SwathIsoSurfacesBuildMeshTask(context, mesh, chunkIndex, *groupComp, isoComp, isoData, dataData);
      };
 
      SwathPathMeshManager::CreateEntity createEntity =
        [context, containerPtr]() -> EntityPtr
      {
        return context->store->createChildEntity("EchoChunkSurface", containerPtr);
      };
 
      SwathPathMeshManager::ActivateEntity activateEntity =
        [&isoData](EntityPtr e, uint32_t /*ix*/)
      {
        auto mshRndCmp = e->getComponent<SubMeshRenderComponent>();
        
        mshRndCmp->materials.resize(isoData.layerMaterialInstances.size());
 
        for (size_t i = 0; i < isoData.layerMaterialInstances.size(); i++) {
          mshRndCmp->materials[i] = isoData.layerMaterialInstances[i];
        }
 
        mshRndCmp->setChanged();
      };
 
      isoData.runMeshManager = isoData.meshManager.update(context,
                                                          isoData.chunks,
                                                          createBuildFunc,
                                                          createEntity,
                                                          activateEntity);
      activateMeshes = true;
    }
    if (!isoData.meshManager.ready()) {
      context->engine->triggerUpdate();
    }
  }
 
  // Swap meshes so that they participate when creating building boxes.
  if(activateMeshes) {
    context->engine->swapResources();
  }
}