PingIsoSystem.cpp

#include "Context.h"
#include "EntityStore.h"
#include "Components/Core/MeshComponent.h"
#include "Components/Core/SubMeshRenderComponent.h"
#include "Systems/Core/TransformSystem.h"
#include "Resources/MeshManager.h"
#include "Resources/MaterialManager.h"
#include "Services/TaskManager.h"
 
#include "../Components/DataSetComponent.h"
#include "../Components/DataRefComponent.h"
#include "../Components/LocationComponent.h"
#include "../Components/BeamGroupComponent.h"
 
#include "../Systems/DataSetSystem.h"
#include "../Tasks/SinglePingIsoSurfacesTasks.h"
#include "PingIsoSystem.h"
#include "../Utils.h"
 
#include "Foundation/Logging/Logger.h"
 
namespace {
  Cogs::Logging::Log logger = Cogs::Logging::getLogger("EchoPingIsoSystem");
}
 
 
using Cogs::Core::Context;
using namespace Cogs::Core::EchoSounder;
 
void PingIsoSystem::initialize(Context * context)
{
  ComponentSystemWithDataPool::initialize(context);
  surfaceMaterial = context->materialManager->loadMaterial("ParametricGrid.material");
  context->materialManager->processLoading();
  rangeKey = surfaceMaterial->getVec4Key("range");
  opacityKey = surfaceMaterial->getFloatKey("opacity");
}
 
void PingIsoSystem::update(Context* context)
{
  bool activateMeshes = false;
  for (auto & isoComp : pool) {
    auto & isoData = getData(&isoComp);
 
    const Cogs::Core::EchoSounder::DataSetComponent* dataComp;
    const Cogs::Core::EchoSounder::DataSetData* dataData;
    if (!getDataSet(&dataComp, &dataData, isoComp, dataSetSystem)) {
      isoComp.setChanged();
      isoData.dataComp = nullptr;
      continue;
    }
    const auto * groupComp = isoComp.getComponent<BeamGroupComponent>();
    if (!groupComp || !groupComp->sane) {
      isoComp.setChanged();
      continue;
    }
 
    // Check for things that trigger reissue of geometry creation.
    if (isoData.dataComp != dataComp) {
      isoData.dataComp = dataComp;
      isoData.reIssue = true;
    }
 
    const auto * locComp = isoComp.getComponent<LocationComponent>();
    if (isoData.index != locComp->index) {
      isoData.index = locComp->index;
      isoData.reIssue = true;
    }
 
    if (dataComp->hasChanged()) {
      isoData.reIssue = true;
    }
 
    bool updateMaterials = isoComp.hasChanged();
 
    // Check if we should re-create geometry
    if (!isoData.reIssue) {
      if (isoComp.hasChanged()) {
        const Reflection::FieldId firstNonTriggeringField = isoComp.getType().getFieldId(&PingIsoComponent::material);
        for (Reflection::FieldId fieldId = 0; fieldId < firstNonTriggeringField; fieldId++) {
          if (isoComp.hasFieldChanged(fieldId)) {
            isoData.reIssue = true;
            break;
          }
        }
      }
      if (groupComp->hasChanged()) {
        isoData.reIssue = true;
      }
    }
 
    bool tasksAreRunning = isoData.persistent->runningTasks > 0;
    bool triggerUpdate = false;
    // No worker tasks running? No need to lock persistent, as no other tasks are running
    if (!tasksAreRunning) {
 
      // Mesh ready to be presented?
      if (isoData.persistent->issuedMesh) {
        if (isoData.persistent->issuedMesh->isActive()) {
          auto * meshComp = isoComp.getComponent<MeshComponent>();
          meshComp->meshHandle = isoData.persistent->issuedMesh;
          meshComp->setChanged();
 
          auto * trComp = isoComp.getComponent<TransformComponent>();
          trComp->position = isoData.persistent->issuedPosition;
          trComp->rotation = isoData.persistent->issuedOrientation;
          trComp->setChanged();
          context->transformSystem->updateTransformData(*trComp);
 
          // Create new material instances if needed.
          while (isoData.layerMaterialInstances.size() < isoData.thresholds.size()) {
            isoData.layerMaterialInstances.push_back(context->materialInstanceManager->createMaterialInstance(surfaceMaterial));
          }
          isoData.layerMaterialInstances.resize(isoData.thresholds.size());
 
          auto mshRndCmp = isoComp.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();
 
          updateMaterials = true;
          activateMeshes = true;
          isoData.persistent->issuedMesh = MeshHandle::NoHandle;
        }
        else {
          triggerUpdate = true;
        }
      }
 
      //Should we issue construction of a new mesh?
      if (isoData.reIssue) {
 
        // Limited by MeshRenderComponent, that only has 16 material slots.
        if (16 < isoComp.thresholds.size()) {
          isoComp.thresholds.resize(16);
        }
        isoData.thresholds = isoComp.thresholds;
        isoData.seabedClipOffset = isoComp.seabedClipOffset;
 
        isoData.persistent->runningTasks++;
 
        auto task = context->taskManager->create(context->taskManager->GlobalQueue,
                                                 SinglePingIsoSurfacesMainTask(context,
                                                                         &isoComp, &isoData,
                                                                         groupComp,
                                                                         dataComp, dataData));
        context->taskManager->enqueue(task);
 
        isoData.reIssue = false;
        triggerUpdate = true;
      }
 
    }
 
    // Update material properties
    if (updateMaterials && isoComp.material) {
      for (size_t i = 0; i < isoData.layerMaterialInstances.size(); i++) {
        isoData.layerMaterialInstances[i]->clone(isoComp.material.resolve());
 
        if (isoComp.innerLayerOpaque && i + 1 == isoData.layerMaterialInstances.size()) {
          isoData.layerMaterialInstances[i]->setOpaque();
        }
        else {
          isoData.layerMaterialInstances[i]->setTransparent();
        }
        isoData.layerMaterialInstances[i]->setVec4Property(rangeKey, glm::vec4(0, 1, 0, 1));
        isoData.layerMaterialInstances[i]->setFloatProperty(opacityKey, isoComp.opacity);
        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;
      }
    }
 
    if (tasksAreRunning || triggerUpdate) {
      context->engine->triggerUpdate();
    }
  }
 
  if (activateMeshes) {
    context->engine->swapResources();
  }
}
 
void PingIsoSystem::cleanup(Context* context)
{
  ComponentSystemWithDataPool::cleanup(context);
}