SinglePingIsoSurfacesTasks.h

#pragma once
#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
#include <memory>
#include <vector>
#include "../Systems/DataSetSystem.h"
 
namespace Cogs
{
  namespace Core
  {
    class Context;
 
    namespace EchoSounder
    {
      struct BeamGroupComponent;
      struct PingIsoComponent;
      struct SinglePingIsoSurfacesData;
      struct DataSetComponent;
      struct DataSetData;
 
      struct SinglePingIsoSurfacesPersistent;
 
      struct SinglePingIsoSurfacesMainTask
      {
        // Copied in constructor
        std::shared_ptr<SinglePingIsoSurfacesPersistent> persistent;
        Context*           context;
        uint32_t           index;
        std::vector<float> thresholds;
        bool               flipOrientation;
        bool               beamMinorClosed;
        PingMetaData       metaPing;
        uint32_t           layers;
        uint32_t           beamCount;
        uint32_t           beamMinorCount;
        uint32_t           beamMajorCount;
        uint32_t           sampleCount;
        uint32_t           coordSys;
        float              capSeparation;
        float              seabedClipOffset;
        float              depthOffset;
        float              depthStep;
        bool               logarithmicUnit;
        float              depthStepResample;
        float              beamStepResample;
        float              maxBeamUpsample;
        float              overflowThreshold;
        float              minVerticalDepth;
        float              maxVerticalDepth;
 
        std::vector<float> directionX; // Separated, major.
        std::vector<float> directionY; // Separated, minor.
 
        std::vector<glm::vec3>  rayDir;
        std::vector<float> depths;
        int sampleCountResample = 0;
 
        SinglePingIsoSurfacesMainTask(Context* context,
                                      const PingIsoComponent* isoComp, const SinglePingIsoSurfacesData* isoData,
                                      const BeamGroupComponent* groupComp,
                                      const DataSetComponent* dataComp, const DataSetData* dataData);
 
        // Working memory
        std::vector<float>   linearThresholds;
        std::vector<int>     vertexOffsets;
        std::vector<int>     vertexCounts;
        std::vector<int>     indexOffsets;
        std::vector<int>     indexCounts;
        std::vector<int>     cellCounts;
 
        void operator()();
      };
    }
  }
}