vrfGuiSimObjectManager.h

Go to the documentation of this file.

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

#pragma once

#include <vrfGuiCore/vrfGuiCore.h>
#include <vrfGuiCore/guiLocalObject.h>

#include <vrfStateData/simObjectManagerTemplate.h>

#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvCore/DtUniqueID.h>
#include <vrvCore/DtSelectionManager.h>
#include <tbb/spin_rw_mutex.h>

#include <unordered_map>
#include <unordered_set>
#include <boost/signals2.hpp>

namespace makVrv
{
   class DtCoordinateSystem;
}

namespace makVrf
{
   class DtStateDataManager;

   typedef boost::function<int (const DtEntityType&)> DtMaxMarkingTextLengthFunction;

   class DT_DLL_VRFGUICORE DtVrfGuiSimObjectManager : public makVrv::DtVirtualBaseClass
   {
   public:
      class GuiSimObjectManager : public DtSimObjectManagerTemplate<DtGuiSimObject>
      {
      public:
         GuiSimObjectManager(makVrv::DtDe& de, DtStateDataManager*);
         const SimObjects& simObjects() const
         {
            return mySimObjects;
         }

         virtual DtSimObjectReference addReference(DtGuiLocalObject&);
         virtual void removeReference(makVrv::DtUniqueID);

         virtual void addVantageReference(DtSimObjectReference);
         virtual void removeVantageReference(DtSimObjectReference);

      protected:
         virtual DtStateDataWrapper* createSimObject(DtStateData*) const override;
         virtual DtStateDataWrapper* createSimObject(const DtUUID& uuid) const override;
         virtual DtStateDataWrapper* createSimObject(const DtEntityIdentifier& entid) const override;

      protected:
         makVrv::DtDe& myDe;
      };

   public:
      DtVrfGuiSimObjectManager(makVrv::DtDe&);
      virtual ~DtVrfGuiSimObjectManager() override;

      static DtVrfGuiSimObjectManager& instance(makVrv::DtDe&);

      virtual DtSimObjectReference lookup(makVrv::DtUniqueID) const;
      DtSimObjectReference findStateView(makVrv::DtUniqueID id) const { return lookup(id); };

      virtual DtSimObjectReference lookup(const DtUUID&) const;
      DtSimObjectReference findStateView(const DtUUID& id) const { return lookup(id); };

      const std::map<DtUUID, DtGuiLocalObject*>& localObjects() const
      {
         return myLocalObjects;
      }

      virtual bool has(const DtUUID&) const;
      virtual bool has(unsigned long long) const;

      virtual DtVector locationOf(makVrv::DtUniqueID id);

      virtual bool stateDataExists(makVrv::DtUniqueID) const;
      virtual makVrv::DtUniqueID uniqueIdFromUUID(const DtUUID&) const;
      virtual std::string lookupNameById(makVrv::DtUniqueID) const;
      virtual std::vector<DtSimObjectReference> lookup(const makVrv::DtSelectionManager::IdSet&) const;

      virtual makVrv::DtUniqueID elementIdFromUUID(const DtUUID&) const;

      typedef std::unordered_map<DtUUID, DtSimObjectReference> SimObjectsByUUID;
      using SimObjects = SimObjectsByUUID;
      const SimObjectsByUUID& simObjects() const
      {
         return mySimObjectsByUUID;
      }

      virtual DtUUID objectUUID(makVrv::DtUniqueID) const;

      virtual void slot_tick();

      virtual makVrv::DtUniqueID displayIdFromSimId(const makVrv::DtUniqueID& id, makVrv::DtModelSetId modelSet = makVrv::DtModelSetId::Unspecified) const;
      virtual makVrv::DtElementData::SceneObjectIdList displayIdsFromSimId(const makVrv::DtUniqueID& id, makVrv::DtModelSetId modelSet = makVrv::DtModelSetId::Unspecified) const;

      virtual makVrv::DtUniqueID simIdFromDisplayId(const makVrv::DtUniqueID& id) const;

      virtual makVrv::DtElementEntry::ElementType elementType(const makVrv::DtElementID&) const;

      virtual const std::set<makVrv::DtUniqueID>& dIGuyIds();
      virtual const std::set<makVrv::DtUniqueID>& tacticalGraphicElements() const;

      virtual const DtString& entityName(makVrv::DtElementID) const;
      virtual DtVector centerOfMass(const std::set<DtUUID>& uuids, bool ignoreEmbarked = true) const;
      virtual makVrv::DtUniqueID parentId( const makVrv::DtUniqueID& id ) const;
      virtual std::string overlayName(const makVrv::DtUniqueID simId) const;

      virtual bool clearing() const;

      virtual void signalWhenAllObjectsDiscovered(const std::map<short, int>&);

      typedef boost::signals2::signal<void (DtSimObjectReference, DtStateComponent::StateComponentType)> StateComponentSignal;
      struct StateComponent
      {
         StateComponent()
         : signal_stateComponentAdded(new StateComponentSignal)
         , signal_stateComponentRemoved(new StateComponentSignal)
         {};

         StateComponent(const StateComponent& orig)
         : signal_stateComponentAdded(orig.signal_stateComponentAdded)
         , signal_stateComponentRemoved(orig.signal_stateComponentRemoved)
         , connections(orig.connections)
         {};

         StateComponent& operator=(const StateComponent& rhs)
         {
            signal_stateComponentAdded = rhs.signal_stateComponentAdded;
            signal_stateComponentRemoved = rhs.signal_stateComponentRemoved;
            connections = rhs.connections;

            return *this;
         }

         std::shared_ptr<makVrv::DtSignalConnectionManager> connections;
         std::shared_ptr<StateComponentSignal> signal_stateComponentAdded;
         std::shared_ptr<StateComponentSignal> signal_stateComponentRemoved;
      };

      virtual void resizeContainer(unsigned);

      template <typename T_Component>
      StateComponentSignal& signalWhenStateComponentAdded()
      {
         resizeContainer(T_Component::ComponentType());
         return *(myStateComponentSignals[T_Component::ComponentType()].signal_stateComponentAdded);
      }

      template <typename T_Component>
      StateComponentSignal& signalWhenStateComponentRemoved()
      {
         resizeContainer(T_Component::ComponentType());
         return *(myStateComponentSignals[T_Component::ComponentType()].signal_stateComponentRemoved);
      }

      boost::signals2::signal<void (DtSimObjectReference)> signal_objectAdded;
      boost::signals2::signal<void (DtSimObjectReference)> signal_objectDeleted;
      boost::signals2::signal<void (const DtUUID&, const DtUUID&, DtSimObjectReference)> signal_uuidChanged;
      boost::signals2::signal<void (const DtString&, const DtString&, DtSimObjectReference)> signal_objectRenamed;

      boost::signals2::signal <void ()> signal_allObjectsDiscovered;
      boost::signals2::signal <void ()> signal_cleared;

      virtual int maxMarkingTextLengthFor(const DtEntityType&) const;
      virtual void setMaxMarkingTextLengthFunction(DtMaxMarkingTextLengthFunction);
      virtual DtMaxMarkingTextLengthFunction maxMarkingTextLengthFunction() const;

      virtual int defaultMaxMarkingTextLengthFunction(const DtEntityType&);

      virtual void uniqueEntityTypes(makVrv::DtUniqueID, std::vector<DtEntityType>& entityTypes);

      const std::set<makVrv::DtUniqueID>& stealthStates() const
      {
         return myStealthStates;
      }

   protected:
      friend class DtGuiLocalObjectManager;

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

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

   protected:
      virtual void slot_objectAdded(DtSimObjectReference);
      virtual void slot_objectDeleted(DtSimObjectReference);
      virtual void slot_uuidChanged(const DtUUID& oldUUID, const DtUUID& newUUID);
      virtual void slot_objectRenamed(DtSimObjectReference ref, const DtString& oldName, const DtString& newName);
      virtual void slot_stateDataModified(DtSimObjectReference);
      virtual void uniqueEntityTypes(makVrv::DtUniqueID, std::vector<DtEntityType>& entityTypes, std::set<std::string>& typesChecked);
      virtual void slot_guiLocalObjectDeleted(DtGuiLocalObject*);
      virtual void slot_gateUnlocked();
      virtual void slot_gateLocked();
      virtual void slot_modelSetLoaded();
      virtual void completeDeletion(DtSimObjectReference o);
      virtual void slot_stateComponentAdded(DtStateComponent*);
      virtual void slot_stateComponentRemoved(DtStateComponent*);
      virtual void setupComponentModifiedConnections();
      virtual void slot_onCoordinateSystemChanged(const std::string& coordinateSystem, const std::string& coordinateParameters);

   protected:
      friend class DtVrfConnectionHelper;
      virtual void setStateDataManager(DtStateDataManager*);

   protected:
      tbb::spin_rw_mutex myComponentMutex;
      typedef std::map<DtUUID, std::set<int>> ComponentsAddedRemoved;

      ComponentsAddedRemoved myComponentsAdded;
      ComponentsAddedRemoved myComponentsRemoved;

      std::set<makVrv::DtUniqueID> myStealthStates;
      DtEntityType myStealthType;
      makVrv::DtDe& myDe;
      DtStateDataManager* myStateDataManager = nullptr;
      GuiSimObjectManager* mySimObjectManager = nullptr;
      boost::signals2::connection myTickConnection;
      makVrv::DtSignalConnectionManager myConnectionManager;
      tbb::spin_mutex myUpdatedMutex;
      std::map<int, std::set<DtSimObjectReference>> myComponentsUpdated;
      std::set<DtSimObjectReference> myObjectsUpdated;
      std::set<DtSimObjectReference> myObjectsDeleted;

      std::set<makVrv::DtUniqueID> myTacticalGraphicElements;
      std::set<makVrv::DtUniqueID> myDIGuyIds;
      std::unordered_set<makVrv::DtUniqueID> myIdsToCheckForDIGuy;
      DtMaxMarkingTextLengthFunction myMaxMarkingTextLengthFunction;
      std::map<short, int> myWaitingForDiscovery;

      boost::signals2::scoped_connection myGateLockedConnection;
      boost::signals2::scoped_connection myGateUnlockedConnection;

      DtStateDataManager* myGuiStateDataManager = nullptr;
      makVrv::DtSignalConnectionManager myConnections;

      std::map<DtUUID, DtGuiLocalObject*> myLocalObjects;

      typedef std::vector<StateComponent> StateComponentSignals;
      StateComponentSignals myStateComponentSignals;

      SimObjectsByUUID mySimObjectsByUUID;

      typedef std::unordered_map<DtUUID, unsigned long long> IdsByUUID;
      IdsByUUID myIdsByUUID;

      std::map<DtUUID, DtUUID> myUUIDChanged;
      tbb::spin_rw_mutex myUUIDChangedMutex;
      tbb::spin_mutex myAdvanceFrameMutex;

      makVrv::DtCoordinateSystem* myCoordinateSystem = nullptr;
      bool myClearing = false;
   };

   DT_DLL_VRFGUICORE std::vector<DtUUID> convertMarkingTextVectorToUUIDVector(const std::vector<DtString>& v);
   DT_DLL_VRFGUICORE std::vector<DtUUID> convertMarkingTextVectorToUUIDVector(const std::vector<std::string>& v);

   DT_DLL_VRFGUICORE std::vector<std::string> convertUUIDVectorToUUIDStringVector(const std::vector<DtUUID>& v);

   DT_DLL_VRFGUICORE std::vector<std::string> convertUUIDVectorToMarkingTextVector(const std::vector<DtUUID>& v);
}