DtTaxiwaySignManager.h

Go to the documentation of this file.

/****************************************************************************** 
** Copyright (c) 2022 MAK Technologies, Inc. 
** All rights reserved. 
******************************************************************************/


#pragma once
#include <vrvCore/DtDe.h>
#include <vrvCore/DtTaxiwaySignLetter.h>
#include <vrvCore/DtUniqueID.h>

#include <vrvOsg/vrvOsg.h>

#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvUtil/DtLockedBufferedQueue.h>

#include <vrvUtil/DtSignalConnectionManager.h>

#include <matrix/vlVector.h>
#include <osg/Group>

#include <unordered_map>

namespace makVrv 
{
   class DtOsgArticulatedModel;
   class DtTaxiwaySignParser;
   class DtTextureAtlasIndexParser;
   struct DtRunwayData;
   class DtSceneObject;
   class DtTaxiwaySignSignaler;
   class DtCoordinateSystem;

   struct DT_DLL_VRVOSG DtTaxiwaySignData
   {
      std::string apt_icao;
      int size;
      std::string text;
      double heading;
      DtVector location;
   };

   // via DtTaxiwaySignSignaler
   class DT_DLL_VRVOSG DtTaxiwaySignNode : public osg::Group
   {
   public:
      DtTaxiwaySignNode(DtDe& de, DtTaxiwaySignData& signData, DtTaxiwaySignSignaler& taxiwaySignSignaler);

      virtual ~DtTaxiwaySignNode();

   public:
      DtDe& myDe;
      DtTaxiwaySignData mySignData;
      DtTaxiwaySignSignaler& myTaxiwaySignSignaler;
   };

   class DT_DLL_VRVOSG DtTaxiwaySignSignaler : public DtVirtualBaseClass
   {
   public:
      static DtTaxiwaySignSignaler& instance(DtDe& anIG);

      virtual ~DtTaxiwaySignSignaler();

      boost::signalslib::signal<void ( DtTaxiwaySignData& )> signal_TaxiwaySignCreated;

      boost::signalslib::signal<void ( DtTaxiwaySignData& )> signal_TaxiwaySignDeleted;

      boost::signalslib::signal<void ( DtRunwayData& )>  signal_RunwayCreated;

      boost::signalslib::signal<void ( DtRunwayData& )>  signal_RunwayDestroyed;
      
   protected:

      DtTaxiwaySignSignaler();

   };

   class DT_DLL_VRVOSG DtTaxiwaySignManager : public DtVirtualBaseClass
   {
   public:

      typedef std::vector<DtTaxiwaySignLetter> TaxiwaySignSide;

      typedef std::unordered_map<DtUniqueID, DtOsgArticulatedModel* > 
         TaxiwaySignsMap;

      typedef std::unordered_map<DtUniqueID, std::vector<DtOsgArticulatedModel*> > 
         RunwaySignMap;

      typedef std::unordered_map<DtUniqueID, DtSceneObject* > 
         SceneObjectMap;

      enum RunwaySignType
      {
         SIDED_SINGLE,
         SIDED_DOUBLE
      };

      enum RunwaySignPlacement
      {
         PLACEMENT_LEFT,
         PLACEMENT_RIGHT
      };

      static DtTaxiwaySignManager& instance(DtDe& anIG);

      virtual ~DtTaxiwaySignManager();

      virtual void slot_TaxiwaySignCreated(DtTaxiwaySignData& signData);

      virtual void slot_TaxiwaySignDestroyed(DtTaxiwaySignData& signData);

      virtual void slot_RunwayCreated(DtRunwayData& runwayData);

      virtual void slot_RunwayDestroyed(DtRunwayData& runwayData);
      
      virtual std::size_t hashPos(DtVector& pos);

      virtual std::size_t hashRunwayData(DtRunwayData& data);

      virtual void setTaxiwayDesignator(DtOsgArticulatedModel* taxiwaySign, 
         const std::string& atlasFileName, const std::string& text);

      virtual void setModelDefinitionForSize(unsigned int size, const std::string& modelDef);

      virtual void clearModelDefinitionForSize(unsigned int size);

      // default is SignTaxiwaySign
      virtual void setDefaultModelDefinition(const std::string& modelDef);

      virtual void setSignMaxSegments(unsigned int maxSegments);

      virtual void setSignCharactersPerSegment(unsigned int charsPerSegment);

      virtual void setTaxiwaySignUVOffsets(
         DtOsgArticulatedModel* taxiwaySign, TaxiwaySignSide& sign, 
         unsigned int numChars);

      virtual bool setMaxSignLimits(unsigned int& numSegments, unsigned int& numChars);

      virtual void updateTaxiwaySignManager(const float budget);

      virtual void createTaxiwaySign(DtTaxiwaySignData& signData);

      virtual void createRunwaySigns(DtRunwayData& runwayData, 
         const RunwaySignType signType, const RunwaySignPlacement signPlacement);

      virtual void createAndPlaceHalfwayRunwayDistanceSign(
         const DtRunwayData &runwayData, const double signWidthOffset, 
         const RunwaySignPlacement signPlacement, DtUniqueID runwayID);

      virtual void extractRunwayStartAndForward(const DtRunwayData &runwayData, 
         DtVector &centerStartPoint, DtVector &forwardVector, 
         const RunwaySignPlacement signPlacement);

      virtual void generateSignLocationsAndStrings(std::vector<DtVector>& signLocations, 
         std::vector<std::string>& signLabels, const double signSpacing, 
         const double signOffset, RunwaySignType signType, 
         const RunwaySignPlacement signPlacement, const DtRunwayData& runwayData);

      virtual DtVector generateRightVectorAtPos(const DtVector& currPos, 
         const double headingDeg);

      virtual void createAndPlaceRunwayDistanceSign(const DtVector& signLoc, 
         const std::string& label, const RunwaySignPlacement signPlacement, 
         const double heading, const unsigned int signSize, DtUniqueID runwayID);

      virtual std::string generateSignLabel(unsigned int signNum);

      virtual DtVector calcRunwayHalfwaySignPos(const double signOffset, 
         const RunwaySignPlacement signPlacement, const DtRunwayData& runwayData);

      double offsetForDistanceSignSize(unsigned int size);

      DtVector geodeticToCig(const DtVector& pos) const;

   public:

      boost::signalslib::signal<void ( DtTaxiwaySignData& )> signal_TaxiwaySignDeleted;
      boost::signalslib::signal<void ( DtTaxiwaySignData& )> signal_TaxiwaySignCreated;

   protected:
         virtual void slot_coordinateSystemChanged();
   protected:

      DtTaxiwaySignManager(DtDe& de);

      DtDe& myDe;
      DtSignalConnectionManager myConnections;
      DtTaxiwaySignParser* mySignParser;
      DtTextureAtlasIndexParser* myTaxiwaySignTextureAtlasParser;
      // For creating DtOsgArticulated models on the main thread
      DtLockedBufferedQueue<DtTaxiwaySignData> mySignDataLockedQueue;
      DtLockedBufferedQueue<DtRunwayData> myRunwayDataLockedQueue;

      DtLockedBufferedQueue<DtTaxiwaySignData> mySignDataToRemoveLockedQueue;
      DtLockedBufferedQueue<DtRunwayData> myRunwayDataToRemoveLockedQueue;

      TaxiwaySignsMap myTaxiwaySigns;
      // Each runway has a vector of signs that are generated around it for
      // end of runway distance markers
      // They are created when the runway is created and deleted when the runway
      // is deleted
      RunwaySignMap myRunwaySigns;
      // The signs are DtOsgArticulatedModels, they are put under a DtSceneObject
      // so that they work when instancing is off
      // The DtSceneObject doesn't have the transform, the articulated model does
      SceneObjectMap mySceneObjs;

      std::map<unsigned int, std::string> myTaxiwaySignModelDefinitions;
      std::string myDefaultTaxiwaySignModelDefinition;
      unsigned int myTaxiwaySignModelMaxSegments;
      unsigned int myTaxiwaySignModelLettersPerSegment;

      std::vector<DtTaxiwaySignData> myTaxiSignCreationVector;
      std::vector<DtRunwayData> myRunwayCreationVector;

      DtCoordinateSystem* myCoordinateSystem = nullptr;

   private:

      void remove(DtTaxiwaySignData& signData);
      void remove(DtRunwayData& runwayData);

};
}