BeamUtils.h

#pragma once
#include "Resources/Resources.h"
#include "Components/BeamGroupComponent.h"  // Topology enum
 
#include "Foundation/Memory/MemoryBuffer.h"
 
#include <glm/glm.hpp>
 
#include <vector>
 
namespace Cogs
{
  namespace Core
  {
    class Context;
 
    namespace EchoSounder
    {
 
      // \param alpha   OwnShip/Transducer/TransducerAlpha[X|Y|Z], converted from degrees to radians.
      // \param offset  OwnShip/Transducer/Offset[X|Y|Z] in meters.
      void getArrayToVesselTransform(glm::quat& rotation,
                                     glm::vec3& translation,
                                     const glm::vec3& alpha,
                                     const glm::vec3& offset);
 
      // Build a beam direction in array coordinates.
      glm::vec3 getBeamDir(uint32_t coordSys, float dirX, float dirY);
 
      // Check if beams have the larger extent in x-direction than in y-direction
      bool isXDominant(const std::vector<float> &directionX, const std::vector<float> &directionY);
 
      void inflateFans(std::vector<float>& directionX,
                       std::vector<float>& directionY,
                       const std::vector<float>& inDirectionX,
                       const std::vector<float>& inBeamWidthX,
                       const std::vector<float>& inDirectionY,
                       const std::vector<float>& inBeamWidthY,
                       const std::vector<uint32_t>& beams,
                       const Topology topology,
                       const size_t minorCount);
 
      void getBoundingFrustum(glm::vec4* planes,
                              const glm::quat& rotation,
                              const glm::vec3& translation,
                              const uint32_t coordSys,
                              const float minDirX, const float maxDirX,
                              const float minDirY, const float maxDirY,
                              const float depthMin, const float depthMax);
 
      void getAxisAlignedBoundingBox(glm::vec3& minCorner,
                                     glm::vec3& maxCorner,
                                     const glm::quat& rotation,
                                     const glm::vec3& translation,
                                     const uint32_t coordSys,
                                     const float minDirX, const float maxDirX,
                                     const float minDirY, const float maxDirY,
                                     const float depthMin, const float depthMax);
 
      MeshHandle buildBeamBundleOutline(Context* context,
                                        const glm::quat& rotation,
                                        const glm::vec3& translation,
                                        const uint32_t coordSys,
                                        const float* dirX, const size_t nX,
                                        const float* dirY, const size_t nY,
                                        const float depthMin, const float depthMax);
 
      void buildBeamBundleOutline2(std::vector<glm::vec3>& V,
                                   std::vector<uint32_t>& indices,
                                   Context* context,
                                   const glm::quat& rotation,
                                   const glm::vec3& translation,
                                   const uint32_t coordSys,
                                   const float* dirY, const size_t nY,
                                   const float* dirX, const size_t nX,
                                   const float depthMin, const float depthMax,
                                   const bool minorClosed,
                                   const bool individualBeams);
 
 
      MeshHandle buildFrustumOutline(Context* context,
                                     const glm::vec4* equations);
 
 
      MeshHandle buildBoxOutline(Context* context,
                                 const glm::vec3& minCorner,
                                 const glm::vec3& maxCorner);
 
      void clipVertical(Cogs::Memory::TypedBuffer<float> & values, size_t startValueIndex,
                        const glm::vec3 & beamStartPos,
                        const std::vector<glm::vec3> & beamDir, const size_t startBeamIndex,
                        const float minVerticalDepth, const float maxVerticalDepth,
                        const float depthOffset, const float depthStep, const float maxRange,
                        const size_t beamCount, const size_t sampleCount);
    }
  }
}