DtAerodromeRenderer.h

Go to the documentation of this file.

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

 
#pragma once

#include <vrvCore/DtDe.h>
#include <vrvOsg/vrvOsg.h>
#include <vrvUtil/DtSignalConnectionManager.h>

#include <osgEarthAerodrome/AerodromeCatalog>
#include <osgEarthAerodrome/AerodromeFactory>

#include <boost/unordered_map.hpp>
#include <OpenThreads/Mutex>

namespace makVrv 
{
   class DtRunwayDesignatorNode;
   class DtRunwayMarkingNode;
   class DtTextureAtlasIndexParser;
   class DtTaxiwaySignSignaler;

   class DT_DLL_VRVOSG DtAerodromeRenderer : public osgEarth::Aerodrome::AerodromeRenderer
   {
   public:

      typedef struct RunwayPolygonData
      {
         RunwayPolygonData()
            : myWidth(0.0f)
            , myLength(0.0f)
            , centerlineStartOffset_ft(0.0f)
            , hasCenterline(false)  // important! (see memory leak defect 58836)
            , myFowardVector(osg::Vec3(1, 0, 0))
            , myThreshold(osg::Vec3(0, 0, 0))
            , useableThreshold(osg::Vec3(0, 0, 0))
         {
         }

         float myWidth;
         float myLength;
         float centerlineStartOffset_ft;
         bool hasCenterline;

         osg::Vec3 myFowardVector;
         osg::Vec3 myThreshold;
         osg::Vec3 useableThreshold;
      };

      typedef boost::unordered_map<std::string, RunwayPolygonData> RunwayPolygonMap;

      typedef struct DtAerodromeData
      {
         std::vector<std::string> rwy1;
         std::vector<std::string> rwy2;

         RunwayPolygonMap myRunwayPolygonMap;
         DtRunwayMarkingNode* myRunwayMarkingNode;
      };

      typedef boost::unordered_map<std::string, DtAerodromeData> DtAerodromeDataMap;


      DtAerodromeRenderer(DtDe& de);

      virtual ~DtAerodromeRenderer();

      virtual void apply(osgEarth::Aerodrome::AerodromeNode& node);

      virtual void apply(osgEarth::Aerodrome::RunwayNode& node);

      virtual void apply(osgEarth::Aerodrome::RunwayThresholdNode& node);

      virtual void apply(osgEarth::Aerodrome::TaxiwaySignNode& node);

      virtual void apply(osgEarth::Aerodrome::LightIndicatorNode& node);

      virtual void apply(osgEarth::Aerodrome::RunwayThresholdGroup& group);

      virtual void parseTaxiwaySignNode(osgEarth::Aerodrome::TaxiwaySignNode &node);

      virtual void parseRunwayNode(osgEarth::Aerodrome::AerodromeFeatureNode& node);

      virtual void parseRunwayThresholdNode(osgEarth::Aerodrome::AerodromeFeatureNode& node);

      virtual void parseLightIndicatorNode(osgEarth::Aerodrome::AerodromeFeatureNode& node);

      virtual void printFeatureAttributes(osgEarth::Aerodrome::AerodromeFeatureNode& node);

      virtual void addRunwayDesignator(const std::string& icao, const std::string& designator, const std::string& tag, 
         const osg::Vec3& threshold, float offset, float centerOffset = 0.0f);

      virtual void addRunwayMarking(const std::string& icao, const std::string& designator, const std::string& tag,
         const osg::Vec3& threshold, float offset, float length, float width, float lateralSpacing);

      virtual void addRunwayThresholdBar(const std::string& icao, const std::string& designator, const osg::Vec3& threshold);

      virtual void addRunwayEdgeMarking(const std::string& icao, const std::string& designator, const osg::Vec3& threshold);

      virtual void addCenterlineMarking(const std::string& icao, const std::string& designator1, const std::string& designator);

      virtual void addDesignator(const std::string& icao, const osg::Vec3Array& verts, const osg::Vec2Array& texCoords);

      virtual void addMarking(const std::string& icao, const osg::Vec3Array& verts, const osg::Vec2Array& texCoords);

   protected:


      //These three functions should be the only way that myDtAerodromeData is accessed
      // They protect any access with a mutex. 

      //Don't call initializeAerodromeData anywhere else unless you really know what you are doing.
      //The Aerodrome data map only contains data for aerodromes that are in the 
      // process of being built. 

      //add a new aerodrome data to the map of aerodrome data
      void initializeAerodromeData(const std::string &icao, makVrv::DtRunwayMarkingNode *markingNode);

      //find the aerodrome data associated with the icao
      DtAerodromeData *findAerodromeData(const std::string &icao);

      //remove the aerodrome data from the map
      virtual void removeAerodromeFromMap(const std::string& icao);


   protected:

      DtDe& myDe;

      DtAerodromeDataMap myDtAerodromeData;
      OpenThreads::Mutex myAerodromeDataMapMutex;


      DtTextureAtlasIndexParser* myTextureAtlasIndexParser;

      RunwayPolygonData* getRunwayPolygonData(const std::string& icao, const std::string& designator);

      DtTaxiwaySignSignaler& myTaxiwaySignSignaler;

      DtSignalConnectionManager myConnections;
   };

   class DT_DLL_VRVOSG DtRunwayMarkingNode : public osg::Node
   {
   public:

      DtRunwayMarkingNode(DtDe& de, DtAerodromeRenderer& renderer, const std::string& icao);

      virtual ~DtRunwayMarkingNode();

      virtual osg::ref_ptr<osg::Geode> buildMarkingDrawable();
      virtual osg::ref_ptr<osg::Geode> buildDesignatorDrawable();

      virtual void addMarking(const osg::Vec3Array& verts, const osg::Vec2Array& texCoords);
      virtual void addDesignator(const osg::Vec3Array& verts, const osg::Vec2Array& texCoords);

      virtual void setTerrainCleared(bool flag);

      virtual bool terrainCleared();

   protected:

      DtDe& myDe;

      std::string icao;
      DtAerodromeRenderer& myRenderer;

      osg::ref_ptr<osg::Vec3Array> myMarkingVerts;
      osg::ref_ptr<osg::Vec2Array> myMarkingTexCoords;

      osg::ref_ptr<osg::Vec3Array> myDesignatorVerts;
      osg::ref_ptr<osg::Vec2Array> myDesignatorTexCoords;

      bool myTerrainCleared;

   };
}