guiLocalObjectManager.h

Go to the documentation of this file.

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

#pragma once

#include <vrfGuiCore/vrfGuiCore.h>
#include <vrfGuiCore/environmentalCreationData.h>
#include <vrfGuiCore/entityCreationData.h>
#include <vrfGuiCore/guiLocalObject.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvCore/DtSelectionManager.h>
#include <vrfGuiCore/vrfObjectManipulationHandlerBaseClass.h>
#include <vrvCore/DtElementAttributes.h>
#include <vrvCore/DtIntersector.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrfutil/predefinedEntityTypes.h>
#include <vlpi/patchIdentifier.h>

#include <vlutil/vlSmartPointers.h>

#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/xml_oarchive.hpp>
#include <boost/serialization/access.hpp>
#include <boost/serialization/nvp.hpp>
#include <boost/serialization/list.hpp>
#include <boost/serialization/map.hpp>
#include <boost/serialization/vector.hpp>
#include <boost/serialization/string.hpp>

#include <matrix/vlVector.h>

class DtEntityType;

namespace makVrv
{
   class DtDe;
   class DtTacticalGraphicOverlay;
   struct DtVrlinkSimulatedBaseState;
   
}

namespace makVrf
{
   class DtVrfObjectFacadeInterface;
   class DtEnvironmentalFacadeCollection;
   class DtEntityFacadeCollection;

   class DT_DLL_VRFGUICORE DtSerializableVector : public DtVector
   {
   public:

      DtSerializableVector() : mySource(0) {};
      DtSerializableVector( DtVector& src )
         : DtVector( src )
         , mySource( &src )
      {
      }

      void operator=(const DtVector& rhs)
      {
         ((DtVector&)*this) = rhs;
      }

   protected:

      friend class boost::serialization::access;

      template<class Archive>
         void serialize(Archive & ar, const unsigned int version)
      {
         double x = myRep[0], y = myRep[1], z = myRep[2];

         ar & BOOST_SERIALIZATION_NVP(x);
         ar & BOOST_SERIALIZATION_NVP(y);
         ar & BOOST_SERIALIZATION_NVP(z);

         if (Archive::is_loading::value)
         {
            myRep[0] = x;
            myRep[1] = y;
            myRep[2] = z;

            if (mySource)
            {
               *mySource = *this;
            }
         }
      }

   protected:
      DtVector* mySource;
   };

   class DT_DLL_VRFGUICORE DtSerializableTaitBryan : public DtTaitBryan
   {
   public:
      DtSerializableTaitBryan() : mySource(0) {};
      DtSerializableTaitBryan(DtTaitBryan& src) :
         DtTaitBryan(src),
         mySource(&src)
      {
      }

   protected:
      friend class boost::serialization::access;

      template<class Archive>
         void serialize(Archive & ar, const unsigned int version)
      {
         ar & BOOST_SERIALIZATION_NVP(myPsi);
         ar & BOOST_SERIALIZATION_NVP(myTheta);
         ar & BOOST_SERIALIZATION_NVP(myPhi);

         if (Archive::is_loading::value && mySource)
         {
            *mySource = *this;
         }
      }

   protected:
      DtTaitBryan* mySource;
   };

   template <typename _Type, typename _SrcType>
   class DtSerializableStdVector
   {
   public:
      DtSerializableStdVector() {};
      DtSerializableStdVector(std::vector<_SrcType>& src) :
      mySource(&src)
      {
         myValues.resize(src.size());

         typename std::vector<_SrcType>::const_iterator srcIter = src.begin();
         typename std::vector<_Type>::iterator tgtIter = myValues.begin();

         while (srcIter != src.end())
         {
            *tgtIter = *srcIter;
            ++srcIter;
            ++tgtIter;
         }
      }

   protected:
      friend class boost::serialization::access;

      template<class Archive>
         void serialize(Archive & ar, const unsigned int version)
      {
         ar & BOOST_SERIALIZATION_NVP(myValues);

         if (Archive::is_loading::value && mySource)
         {
            mySource->clear();
            mySource->resize(myValues.size());

            typename std::vector<_Type>::const_iterator src = myValues.begin();
            typename std::vector<_SrcType>::iterator tgt = mySource->begin();

            while (src != myValues.end())
            {
               *tgt = *src;
               ++src;
               ++tgt;
            }
         }
      }

   protected:
      std::vector<_SrcType>* mySource;
      std::vector<_Type> myValues;
   };


   class DT_DLL_VRFGUICORE DtSerializablePatchIdentifier : public DtPatchIdentifier
   {
   public:

      DtSerializablePatchIdentifier() : mySource( 0 ) {}
      DtSerializablePatchIdentifier( DtPatchIdentifier& src )
         : DtPatchIdentifier( src )
         , mySource( &src )
      {
      }

   protected:

      friend class boost::serialization::access;

      template<class Archive>
      void serialize( Archive& ar, const unsigned int version )
      {
         ar & BOOST_SERIALIZATION_NVP( myCountryCode );
         ar & BOOST_SERIALIZATION_NVP( myServiceCode );
         ar & BOOST_SERIALIZATION_NVP( myPatchId );

         if ( Archive::is_loading::value && mySource )
         {
            *mySource = *this;
         }
      }

   protected:

      DtPatchIdentifier* mySource;

   };

   struct DT_DLL_VRFGUICORE DtVrlinkSimulatedEntityStateContainer
   {
      DtVrlinkSimulatedEntityStateContainer() {};
      DtVrlinkSimulatedEntityStateContainer(const DtGuiLocalObject& obj);

   protected:
      friend class boost::serialization::access;

      template<class Archive>
      void serialize( Archive & ar, const unsigned int version )
      {
         ar & BOOST_SERIALIZATION_NVP( myGlobalId );
         ar & BOOST_SERIALIZATION_NVP( myEntityId );
         ar & BOOST_SERIALIZATION_NVP( myMarkingText );
         ar & BOOST_SERIALIZATION_NVP( myEntityType );
         ar & BOOST_SERIALIZATION_NVP( myAttachedToId );
         ar & BOOST_SERIALIZATION_NVP( myForce );

         DtSerializableVector loc( myLocation );
         DtSerializableVector vel( myVelocity );
         DtSerializableVector relVel( myRelativeVelocity );
         DtSerializableVector acc( myAcceleration );
         DtSerializableTaitBryan ori( myOrientation );
         DtSerializableVector rotVel( myRotationalVelocity );

         ar & BOOST_SERIALIZATION_NVP( loc );
         ar & BOOST_SERIALIZATION_NVP( vel );
         ar & BOOST_SERIALIZATION_NVP( relVel );
         ar & BOOST_SERIALIZATION_NVP( acc );
         ar & BOOST_SERIALIZATION_NVP( ori );
         ar & BOOST_SERIALIZATION_NVP( rotVel );

         ar & BOOST_SERIALIZATION_NVP( myAppearance );
         ar & BOOST_SERIALIZATION_NVP( myCapabilities );

         ar & BOOST_SERIALIZATION_NVP( myDIGuyAppearance );
         ar & BOOST_SERIALIZATION_NVP( myDIGuyCharacterType );

         DtSerializablePatchIdentifier primary( myDIGuyPrimaryUnitPatch );
         DtSerializablePatchIdentifier secondary( myDIGuySecondaryUnitPatch );
         DtSerializablePatchIdentifier rank( myDIGuyRankPatch );

         ar & BOOST_SERIALIZATION_NVP( primary );
         ar & BOOST_SERIALIZATION_NVP( secondary );
         ar & BOOST_SERIALIZATION_NVP( rank );

         ar & BOOST_SERIALIZATION_NVP( myDIGuyCharacterName );

         ar & BOOST_SERIALIZATION_NVP( myGuise );
         ar & BOOST_SERIALIZATION_NVP( myDRAlgorithm );
      }

   public:
      std::string myGlobalId;
      std::string myEntityId;
      std::string myMarkingText;
      std::string myEntityType;
      std::string myAttachedToId;
      int myForce = 0;

      DtVector myLocation;
      DtVector myVelocity;
      DtVector myRelativeVelocity;
      DtVector myAcceleration;
      DtTaitBryan myOrientation;
      DtVector myRotationalVelocity;

      int myAppearance = 0;
      int myCapabilities = 0;

      std::string myDIGuyAppearance;
      std::string myDIGuyCharacterType;

      DtPatchIdentifier myDIGuyPrimaryUnitPatch;
      DtPatchIdentifier myDIGuySecondaryUnitPatch;
      DtPatchIdentifier myDIGuyRankPatch;

      std::string myDIGuyCharacterName;
      std::string myGuise;
      int myDRAlgorithm = 0;
   };

   struct DT_DLL_VRFGUICORE DtVrlinkSimulatedEnvironmentProcessContainer
   {
      DtVrlinkSimulatedEnvironmentProcessContainer() {};
      DtVrlinkSimulatedEnvironmentProcessContainer(const DtGuiLocalObject& obj);

   protected:
      friend class boost::serialization::access;

      template<class Archive>
         void serialize(Archive & ar, const unsigned int version)
      {
         ar & BOOST_SERIALIZATION_NVP(myGlobalId);
         ar & BOOST_SERIALIZATION_NVP(myEntityId);
         ar & BOOST_SERIALIZATION_NVP(myMarkingText);
         ar & BOOST_SERIALIZATION_NVP(myEntityType);
         ar & BOOST_SERIALIZATION_NVP(myAttachedToId);
         ar & BOOST_SERIALIZATION_NVP(myForce);

         DtSerializableStdVector<DtSerializableVector, DtVector> pts(myPoints);

         ar & BOOST_SERIALIZATION_NVP(pts);

         ar & BOOST_SERIALIZATION_NVP(myUserData);
         ar & BOOST_SERIALIZATION_NVP(myPenStyle);
         ar & BOOST_SERIALIZATION_NVP(myFillStyle);
         ar & BOOST_SERIALIZATION_NVP(myLineWidth);
         ar & BOOST_SERIALIZATION_NVP(myColor);
         ar & BOOST_SERIALIZATION_NVP(myLabel);
         ar & BOOST_SERIALIZATION_NVP(myClosedFigure);
         ar & BOOST_SERIALIZATION_NVP(myProjected);
         ar & BOOST_SERIALIZATION_NVP(myAttributes);
         ar & BOOST_SERIALIZATION_NVP(myOverlayParent);

         if (version >= 2)
         {
            ar & BOOST_SERIALIZATION_NVP(myPhysicalLineHeight);
            ar & BOOST_SERIALIZATION_NVP(myPhysicalLineWidth);
         }

         if (version >= 3)
         {
            ar & BOOST_SERIALIZATION_NVP(myExtendedData);
         }
      }

   public:
      std::string myGlobalId;
      std::string myEntityId;
      std::string myMarkingText;
      std::string myEntityType;
      std::string myAttachedToId;
      int myForce = 0;
      std::vector<DtVector> myPoints;
      std::string myUserData;
      int myPenStyle = 0;
      int myFillStyle = 0;
      int myLineWidth = 0;
      int myColor = 0;
      std::string myLabel;
      bool myClosedFigure = false;
      bool myProjected = false;
      int myAttributes = 0;
      std::string myOverlayParent;
      double myPhysicalLineHeight = 1.;
      double myPhysicalLineWidth = 1.;
      std::map<std::string, std::string> myExtendedData;
   };


   class DT_DLL_VRFGUICORE DtGuiLocalObjectManager : public makVrv::DtVirtualBaseClass
   {
   public:
      enum ClampFlag
      {
         Highest = 0,
         Lowest,
         Closest, 
         ClosestDown 
      };

      DtGuiLocalObjectManager(makVrv::DtDe& de);

      static DtGuiLocalObjectManager& instance(makVrv::DtDe& de);
      static void registerInstance(makVrv::DtDe& de, DtGuiLocalObjectManager*);

      virtual ~DtGuiLocalObjectManager() override;

      virtual bool isCreating() const;

      virtual DtGuiLocalObject* createStaticData(const DtEntityType& et, const DtUUID& uuid = DtUUID::nullUUID());

      virtual DtGuiLocalObject* createSharedData(const DtEntityType&, makVrv::DtUniqueID id = 0, const DtUUID& uuid = DtUUID::nullUUID());

      virtual void tacticalGraphicsVertexSelected(
         const makVrv::DtUniqueID& selected, const makVrv::DtUniqueID& parentElementID);

      virtual void tacticalGraphicsVertexDeselected(
         const makVrv::DtUniqueID& deselected, const makVrv::DtUniqueID& parent);

      virtual void slot_onCurrentSelectionChanged(
         const makVrv::DtSelectionManager::IdSet& selected,
         const makVrv::DtSelectionManager::IdSet& deselected);

      virtual DtVrfObjectFacadeInterface* facadeForID(makVrv::DtUniqueID);

      virtual std::vector<makVrv::DtUniqueID> uniqueIdsForTypesThatMatch(const DtEntityType&) const;

      virtual DtEnvironmentalFacadeCollection* create(const DtVrlinkSimulatedEnvironmentProcessContainer&, int dictionartToUse = -1);

      virtual DtEnvironmentalFacadeCollection* create(const DtEntityType& t,
         const std::vector<DtVector>& localPoints,
         int force,
         const DtEnvironmentalCreationData&,
         makVrv::DtModelSetId modelSet = makVrv::DtModelSetId::Unspecified, bool keepName = false, int dictionaryToUse = -1);

      virtual DtEntityFacadeCollection* create(const DtVrlinkSimulatedEntityStateContainer&, const std::string& overlayParent = "",
         int dictionaryToUse = -1);

      virtual DtEntityFacadeCollection* create(const DtEntityCreationData&,
         makVrv::DtModelSetId modelSet = makVrv::DtModelSetId::Unspecified, bool keepName = false, int dictionaryToUse = -1);

      virtual DtVrfObjectFacadeInterface* createObject(const DtVrfObjectManipulationHandlerBaseClass::ObjectManipulationData&, const bool showInObjectList = false);

      virtual const makVrv::DtTacticalGraphicOverlay* createOnLayer(const std::string& layerName = "");

      virtual void completeStateUpdate(DtSimObjectReference, bool forceIfHidden);
      virtual void slot_objectAdded(DtSimObjectReference);

      virtual void setVisible(makVrv::DtUniqueID id, bool hide);

      virtual bool isLocal(makVrv::DtUniqueID id) const;

      virtual void setEditable(makVrv::DtUniqueID id, bool);

      virtual bool isEditable(makVrv::DtUniqueID id, const std::string& keywords = "") const;

      virtual bool isMemberOfLayer(makVrv::DtUniqueID id, const std::string& layername) const;

      virtual void deleteLocal(makVrv::DtUniqueID id);

      virtual void deleteAll(std::vector<DtEntityType> except = std::vector<DtEntityType>());

      virtual void deleteAllFromLayer(const std::string& layername);

      struct LocalObjectUpdateStructure
      {
         LocalObjectUpdateStructure()
            : name( 0 )
            , force( 0 )
            , overlay( 0 )
            , userData( 0 )
            , extendedData( 0 )
            , extendedLabels( 0 )
            , newHeading( 0 )
            , newPitch( 0 )
            , color( 0 )
            , appearance( 0 )
            , label( 0 )
            , physicalLineHeight( 0 )
            , physicalLineWidth( 0 )
         {
            isGeocentric = false;
         }

         LocalObjectUpdateStructure( const DtVrfObjectManipulationHandlerBaseClass::ObjectManipulationData& omd )
            : name( &omd.objectName )
            , force( &omd.force )
            , overlay( &omd.overlay )
            , userData( &omd.userData )
            , extendedData( &omd.extendedData )
            , extendedLabels( &omd.extendedLabels )
            , newHeading( &omd.heading )
            , newPitch( &omd.pitch )
            , color( 0 )
            , appearance( 0 )
            , label( 0 )
            , physicalLineHeight( 0 )
            , physicalLineWidth( 0 )
         {
            isGeocentric = false;
         }

         const std::string* name;
         std::vector<DtVector> points;
         const int* force;
         const std::string* overlay;
         const std::string* userData;
         const std::map<std::string, std::string>* extendedData;
         const std::map<int, DtString>* extendedLabels;
         const double* newHeading;
         const double* newPitch;
         const int* color;
         const int* appearance;
         const std::string* label;
         const float* physicalLineHeight;
         const float* physicalLineWidth;
         bool isGeocentric;
      };

      virtual void update(makVrv::DtElementID id, const LocalObjectUpdateStructure& updateStructure, bool forceUpdate = true);

      virtual DtVector getVertexPosition(makVrv::DtElementID parent, makVrv::DtUniqueID vertexId) const;

      virtual void create(const DtEntityType& t, int force);

      virtual bool allSelectionIsLocal() const;

      virtual void setCanCreateLocalObjects(bool);

      virtual bool canCreateLocalObjects() const;

      virtual void save(const std::string&);

      virtual std::string toStringBuffer();

      virtual bool fromStringBuffer(const std::string&, bool removeAll = true);

      virtual bool load(const std::string&, bool removeAll = true);

      virtual int numberOfLocalObjects() const;

      virtual double groundHeight(const DtVector& lp, makVrv::DtIntersector::IntersectProperties props =
         makVrv::DtIntersector::SupportNodes, ClampFlag clampFlag = Closest, DtVector* clampedPoint = 0,
         const std::vector<makVrv::DtUniqueID>& ignore = std::vector<makVrv::DtUniqueID>(), makVrv::DtUniqueID* hitId = 0) const;

      virtual DtVector clampToGround(const DtVector&, makVrv::DtIntersector::IntersectProperties props =
         makVrv::DtIntersector::SupportNodes, const std::vector<makVrv::DtUniqueID>& ignore = std::vector<makVrv::DtUniqueID>(),
         bool useHighestLOD = false, bool ignoreDynamicOcean = false, ClampFlag useHighestPolygon = Closest,
         makVrv::DtUniqueID* hitId = 0) const;

      virtual DtGeodeticCoord clampToGround(const DtGeodeticCoord&, makVrv::DtIntersector::IntersectProperties props =
         makVrv::DtIntersector::SupportNodes, const std::vector<makVrv::DtUniqueID>& ignore = std::vector<makVrv::DtUniqueID>(),
         bool useHighestLOD = false, bool ignoreDynamicOcean = false, ClampFlag useHighestPolygon = Closest, makVrv::DtUniqueID* hitId = 0) const;

      virtual std::string generateUniqueName(const std::string& base, bool addNumberToBegin = false) const;

      virtual void ignoreFromArchive(const DtEntityType&);
      virtual void removeIgnoreFromArchive(const DtEntityType&);

      const std::map<DtUUID, DtGuiLocalObject*>& localObjects() const;
      virtual DtGuiLocalObject* lookup(makVrv::DtUniqueID) const;
      virtual DtGuiLocalObject* lookup(const DtUUID& id) const;

   protected:
      virtual void slot_objectVisibilityChanged( makVrv::DtUniqueID id, bool isShown, int context );
      virtual void slot_stateDataDeleted(DtGuiLocalObject* lo);

      virtual void update(DtEnvironmentalFacadeCollection*, DtSimObjectReference);
      virtual void update(DtEntityFacadeCollection*, DtSimObjectReference);

      virtual void slot_stoppedObjectCreation();

      virtual bool shouldArchive(const DtGuiLocalObject&) const;

      virtual void clearingTerrain();

   public:
      boost::signals2::signal<void (DtGuiLocalObject*)> signal_localObjectCreated;
      boost::signals2::signal<void(DtGuiLocalObject*)> signal_localObjectAboutToBeRemoved;

      boost::signals2::signal<void (bool)> signal_creating;

      boost::signals2::signal<void (DtVrfObjectFacadeInterface*, const DtEntityType&)> signal_preVisualize;

      boost::signals2::signal<void (DtVrfObjectFacadeInterface*, const DtGuiSimObject&)> signal_objectCreated;

      boost::signals2::signal<void (DtVrfObjectFacadeInterface*)> signal_objectAboutToBeDeleted;

      boost::signals2::signal<void (bool)> signal_loading;

      boost::signals2::signal<void (makVrv::DtUniqueID)> signal_objectDeleted;

      boost::signals2::signal<void ()> signal_terrainClearing;
      boost::signals2::signal<void ()> signal_terrainCleared;


   protected:
      friend class boost::serialization::access;

      template<class Archive>
         void serialize(Archive & ar, const unsigned int version)
      {
         if (Archive::is_loading::value)
         {
            read(*(boost::archive::xml_iarchive*)&ar);
         }
         else
         {
            write(*(boost::archive::xml_oarchive*)&ar);
         }
      }

      virtual void write(boost::archive::xml_oarchive& out);
      virtual void read(boost::archive::xml_iarchive& in);

   protected:
      makVrv::DtDe& myDe;

      bool myIsCreating;

      typedef std::map<makVrv::DtUniqueID, DtVrfObjectFacadeInterface*> LocalObjects;
      LocalObjects myObjects;
      makVrv::DtSignalConnectionManager myConnections;

      typedef std::map<makVrv::DtUniqueID, std::shared_ptr<DtGuiLocalObject>> LocalStateData;
      LocalStateData myData;

      bool myCanCreateLocalObjects;

      std::vector<DtEntityType> myIgnoreFromArchive;

      struct LastCheckedGroundInformation
      {
         LastCheckedGroundInformation()
         : myProps(makVrv::DtIntersector::IntersectProperties(0))
         , myUseHighestLOD(false)
         , myIgnoreDynamicOcean(false)
         , myUseHighestPolygon(Closest)
         , myHitId(0)
         {
         }

         LastCheckedGroundInformation(const DtVector& lp, makVrv:: DtIntersector::IntersectProperties props,
            bool useHighestLOD, bool ignoreDynamicOcean, ClampFlag useHighestPolygon, const std::vector<makVrv::DtUniqueID>& ignore)
         : myCheckPoint(lp)
         , myProps(props)
         , myUseHighestLOD(useHighestLOD)
         , myIgnoreDynamicOcean(ignoreDynamicOcean)
         , myUseHighestPolygon(useHighestPolygon)
         , myHitId(0)
         , myIgnored(ignore)
         {
         }

         virtual ~LastCheckedGroundInformation() {};

         const LastCheckedGroundInformation& operator=(const LastCheckedGroundInformation& orig)
         {
            myCheckPoint = orig.myCheckPoint;
            myProps = orig.myProps;
            myUseHighestLOD = orig.myUseHighestLOD;
            myIgnoreDynamicOcean = orig.myIgnoreDynamicOcean;
            myUseHighestPolygon = orig.myUseHighestPolygon;
            myCheckPoint = orig.myCheckPoint;
            myHitId = orig.myHitId;
            myIgnored = orig.myIgnored;

            return *this;
         }

         bool operator==(const LastCheckedGroundInformation& orig) const
         {
            return ((myCheckPoint == orig.myCheckPoint) &&
               (myProps == orig.myProps) &&
               (myUseHighestLOD == orig.myUseHighestLOD) &&
               (myIgnoreDynamicOcean == orig.myIgnoreDynamicOcean) &&
               (myIgnored == orig.myIgnored) &&
               (myUseHighestPolygon == orig.myUseHighestPolygon));
         }

         DtVector myCheckPoint;
         makVrv:: DtIntersector::IntersectProperties myProps;
         bool myUseHighestLOD;
         bool myIgnoreDynamicOcean;
         ClampFlag myUseHighestPolygon;
         makVrv::DtUniqueID myHitId;
         DtVector myIntersectionPoint;
         std::vector<makVrv::DtUniqueID> myIgnored;
      };

      mutable LastCheckedGroundInformation myLastCheckedGroundInformation;
   };
}

BOOST_CLASS_VERSION(makVrf::DtVrlinkSimulatedEnvironmentProcessContainer,3)