SwathBottomSystem.cpp

#include <glm/glm.hpp>
#include <glm/gtc/type_ptr.hpp>
 
#include "Context.h"
#include "EntityStore.h"
#include "Resources/MeshManager.h"
#include "Components/Core/MeshComponent.h"
#include "Components/Core/MeshRenderComponent.h"
#include "Components/Core/SceneComponent.h"
#include "Components/Appearance/MaterialComponent.h"
 
#include "../Components/BeamGroupComponent.h"
#include "../Components/DataSetComponent.h"
#include "../Components/WindowComponent.h"
#include "../Components/DataRefComponent.h"
#include "DataSetSystem.h"
#include "SwathBottomSystem.h"
 
#include "../Tasks/SwathSeabedBuildMeshTask.h"
 
void Cogs::Core::EchoSounder::SwathBottomSystem::initialize(Context * context)
{
  ComponentSystemWithDataPool::initialize(context);
}
 
void Cogs::Core::EchoSounder::SwathBottomSystem::update(Context* context)
{
  bool activateMeshes = false;
  for (auto & surfComp : pool) {
    auto & surfData = getData(&surfComp);
    const auto * winComp = surfComp.getComponent<WindowComponent>();
    const auto * groupComp = surfComp.getComponent<BeamGroupComponent>();
 
    if (!winComp || !groupComp || !groupComp->sane || groupComp->majorCount != 1) continue;
 
    // beamGroup->sane makes sure that we have data (and that it is sane).
    const auto * dataRefComp = surfComp.getComponent<DataRefComponent>();
    const auto * dataComp = dataRefComp->data->getComponent<DataSetComponent>();
    const auto & dataData = dataSetSystem->getData(dataComp);
 
    if ((surfData.beamGroupGen != groupComp->gen)
      || (surfData.pathSpacing != winComp->pathSpacing)
      || (surfData.beamSpacing != winComp->beamSpacing))
    {
      surfData.pathSpacing = winComp->pathSpacing;
      surfData.beamSpacing = winComp->beamSpacing;
      surfData.beamGroupGen = groupComp->gen;
      surfData.resamplingPositions.clear(surfData.pathSpacing, context->variables->get("echo.maxPathUpsample")->getFloat());
      surfData.chunks.clear();
      surfData.meshManager.clear();
      surfData.runMeshManager = true;
    }
 
    const auto * sceneComp = surfComp.getComponent<SceneComponent>();
 
    bool resampleSitesChanged;
    if (sceneComp->visible) {
      resampleSitesChanged = surfData.resamplingPositions.update(winComp, dataComp, &dataData);
    }
    else {
      resampleSitesChanged = surfData.resamplingPositions.clear(surfData.pathSpacing, context->variables->get("echo.maxPathUpsample")->getFloat());
    }
    if (resampleSitesChanged) {
      if (surfData.chunks.update(surfData.resamplingPositions)) {
        surfData.runMeshManager = true;
      }
    }
 
    if (surfData.meshManager.ready() && surfData.runMeshManager) {
      auto * containerPtr = surfComp.getContainer();
      
 
      SwathPathMeshManager::CreateBuildFunc createBuildFunc = [context, groupComp, &surfComp, &surfData, &dataData](MeshHandle& mesh, uint32_t chunkIndex) -> TaskFunction
      {
        return SwathSeabedBuildMeshTask(context, mesh, chunkIndex, *groupComp, surfComp, surfData, dataData);
      };
 
      SwathPathMeshManager::CreateEntity createEntity = [context, containerPtr]() -> EntityPtr
      {
        auto e = context->store->createChildEntity("MeshPartWithMaterial", containerPtr);
        auto m = e->getComponent<MaterialComponent>();
        m->material = context->store->getEntity(containerPtr->getId());
        return e;
      };
 
      SwathPathMeshManager::ActivateEntity activateEntity = [](EntityPtr /*e*/, uint32_t /*ix*/)
      {
        //auto mcomp = e->getComponent<MaterialComponent>();
        //mcomp->diffuseColor = glm::vec4((ix >> 2) & 1, (ix >> 1) & 1, ix & 1, 1);
        //mcomp->setChanged();
      };
 
      surfData.runMeshManager = surfData.meshManager.update(context,
                                                       surfData.chunks,
                                                       createBuildFunc,
                                                       createEntity,
                                                       activateEntity);
      activateMeshes = true;
    }
 
    if (!surfData.meshManager.ready()) {
      context->engine->triggerUpdate();
    }
  }
 
 
  // Swap meshes so that they participate when creating building boxes.
  if (activateMeshes) {
    context->engine->swapResources();
  }
}