PingOutlineComponent.h

#pragma once
#include <string>
 
#include "EntityDefinition.h"
#include "Components/Core/DynamicComponent.h"
 
#include "Resources/Resources.h"
 
#include <glm/vec3.hpp>
#include <glm/vec4.hpp>
 
namespace Cogs
{
  namespace Core
  {
    namespace EchoSounder
    {
      struct Config;
      struct BeamGroupComponent;
      struct DataSetComponent;
      struct DataSetSystem;
      struct DataSetData;
 
      enum class AnnotationType
      {
        VerticalDepth,  
        Range,   
      };
 
      enum class ConnectedTicksMode {
        None, 
        Fan, 
        Grid, 
      };
 
      //describes where to put the annotation markers. Only meaningfull for grids, at it has four sides it can be placed on
      enum class AnnotationPosition {
        Front,
        Right,
      };
 
      struct PingOutlineComponent : DynamicComponent
      {
        static void registerType();
 
        void initialize(Context * context);
 
        void update();
 
        bool flat = false;
        bool individualBeams = false; // Individual beam geometry or just outline of fan.
        ConnectedTicksMode connectedTicks = ConnectedTicksMode::None;  // Let tick-marks span across fan.
        AnnotationPosition annotationPosition = AnnotationPosition::Front;
        bool showVesselCoordsys = false;
        bool showBoundingFrustum = false;
        bool showAABB = false;
 
        AnnotationType annotationType = AnnotationType::Range;
        int numTickMarks = 10;        // Approx number of ticks, 0 to disable.
        float tickLength = 0.2f;      // Size of tick relative to distance between ticks.
        std::string unit = "";        // Unit of depth values.
        float widthScaleAlongship = 1.f;
        float widthScaleAthwartship = 1.f;
        float depthStart = std::numeric_limits<float>::quiet_NaN();// Set individual depth start, nan uses dataset start.
        float depthRange = std::numeric_limits<float>::quiet_NaN(); // Set individual depth range, nan uses dataset range.
        float verticalDepthMax = std::numeric_limits<float>::quiet_NaN();
 
        glm::vec4 textColor;
      private:
        Context* context = nullptr;
        DataSetSystem* dataSystem = nullptr;
        uint32_t configGen = 0;
        EntityPtr annotation[2];
        EntityPtr vesselCoordSys;
        EntityPtr boundingFrustum;
        EntityPtr axisAlignedBBox;
        EntityPtr annoLineMesh;
 
        void createTickGeometryAndAnnotations(Context* context,
                                              const std::vector<float>& directionX,
                                              const std::vector<float>& directionY,
                                              const uint32_t minorCount,
                                              const uint32_t majorCount,
                                              const bool minorClosed,
                                              const Config& config);
 
        void addAnnotations(std::vector<glm::vec3> &V,
                            std::vector<uint32_t> &indices,
                            size_t tickA, size_t tickB, float depthStep,
                            const std::vector<glm::vec3> &dirs,
                            const glm::vec3 & translation,
                            float maxDistance, bool showTicks, bool connectTicks);
 
        void createBeamCenterGeometry(std::vector<glm::vec3>& V,
                                      std::vector<uint32_t>& indices,
                                      Context* context,
                                      const std::vector<float>& directionX,
                                      const std::vector<float>& directionY,
                                      bool individualBeams,
                                      const uint32_t bN,
                                      const Config& config);
 
        void createBeamExtentGeometry(std::vector<glm::vec3>& V, 
                                      std::vector<uint32_t>& indices,
                                      Context* context,
                                      const std::vector<float>& directionX,
                                      const std::vector<float>& directionY,
                                      const uint32_t bN,
                                      const Config& config);
      };
    }
  }
}
template<> inline Cogs::StringView getName<Cogs::Core::EchoSounder::ConnectedTicksMode>() { return "EchoConnectedTicksMode"; }
template<> inline Cogs::StringView getName<Cogs::Core::EchoSounder::AnnotationType>() { return "EchoAnnotationType"; }
template<> inline Cogs::StringView getName<Cogs::Core::EchoSounder::AnnotationPosition>() { return "EchoAnnotationPosition"; }
 
template<> inline Cogs::StringView getName<Cogs::Core::EchoSounder::PingOutlineComponent>() { return "EchoPingOutlineComponent"; }