DtElement.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/vrvCore.h>
#include <vrvCore/DtSharedModelSetSettings.h>
#include <vrvCore/DtElementAttributes.h>
#include <vrvCore/DtElementEntry.h>
#include <vrvCore/DtVisualizerCreationSettingsManager.h>

#include <vrvCore/DtBaseConnection.h>

#include <vrvUtil/DtUnicode.h>

#include <vector>

#include <boost/unordered_map.hpp>

namespace makVrv
{
   class DtAgentManagerInterface;
   class DtSharedSettingsManager;
   class DtElementDefinition;
   class DtStateListener;
   class DtSceneObjectAgent;
   class DtVisualizerSet;
   enum class DtModelSetId;

   namespace EntityStateListener
   {
      enum class DamageState;
   }

   class DT_DLL_VRVCORE DtElement
   {
   public:

      using ModelSetToSceneObjectIdMap = boost::unordered_map<DtModelSetId, DtUniqueID>;

      DtElement( DtBaseConnection& conn, DtElementID elementId );

      virtual ~DtElement();

      DtElement() = delete;

      DtElement( const DtElement& ) = delete;

      DtElement& operator=( const DtElement& ) = delete;

   public:

      virtual void visualize(const DtSharedModelSetSettings::ModelSetVisualizedMap& sets);            
      
      virtual void setVisible( bool visible );

      virtual bool visible() const;

      virtual void setElementId( const DtElementID );

      inline DtElementID elementID() const
      {
         return myElementId;
      }



      virtual void updateElementDefinitionFromDefinitions();

      virtual void updateElementDefinitionFromDefinitions( std::vector<DtUnicode>& definitions );

      virtual const DtUnicode& elementDefinition() const;
      virtual void setElementDefinition(const DtUnicode& definition);

      virtual std::string displayUnitCollectionName() const;

      virtual void setDisplayUnitCollectionName(const std::string& definition);

      virtual const DtElementEntry::ElementType elementType() const = 0;
      
      virtual void setDriverType(const std::string& driverType);

      virtual void setElementSubtype(DtElementAttributes::ElementSubtypes subtype);

      virtual void changeElementAttribute( const DtElementAttribute* attr );



      virtual ModelSetToSceneObjectIdMap& modelSetToSceneObjectIdMap();

      virtual void setSceneObjectIdForModelSet( DtModelSetId modelSet, DtUniqueID id );

      virtual void removeSceneObjectIdForModelSet( DtModelSetId modelSet ) ;

      virtual DtUniqueID sceneObjectIdForModelSet( DtModelSetId modelSet ) const;

   protected:      



      virtual void reportElementCreated();

      virtual void reportDisplayName();

      virtual void reportConnectionObjectID();

      virtual void reportConnectionObjectType();

      virtual void reportOverlayNameChanged();

      virtual void reportVisibility();

      virtual void reportDamageStateChanged();

      virtual void reportDriverType();

      virtual void reportElementSubtype();

      virtual void reportElementDefinitionName();
      
      virtual void reportDisplayUnitCollectionName();

      void slot_updateOverlayNameRaw(const char* text);

      void slot_updateConnectionObjectID( const std::string& id );

      void slot_updateConnectionObjectType( const std::string& type );

      void slot_updateDisplayName(const std::string& text);

      void slot_updateOverlayName(const std::string& pname);

      void slot_updateDamageState(EntityStateListener::DamageState state);

      virtual void getDefinitions( std::vector<DtUnicode>& definitions );

      virtual void setModelSetEnabled( DtModelSetId modelSet, bool enabled ) = 0;

      virtual bool distribute() const;
      virtual void setDistribute( const bool distribute );

      virtual void warnVisualizationFailed( const std::string& file, int line, const std::string& function,
         DtVisualizerSet* visSet, DtSceneObjectAgent* sceneObject, DtModelSetId modelSet, DtException ex );
      
   protected:      
      DtAgentManagerInterface& mySceneInterface;
      DtSharedSettingsManager& mySettingsManager;
      const DtVisualizerCreationSettings::VisualTypeVisualizerCreationMap& myVisualTypeVisualizerCreationMap;
      DtBaseConnection& myBaseConnection;
      DtElementID myElementId;
      DtUnicode myElementDefinitionName;
      const DtElementDefinition* myElementDefinition;
      std::string myDisplayUnitCollectionName;
      std::string myConnectionObjectID;
      std::string myConnectionObjectType;
      std::string myDisplayName;
      std::string myElementOverlayName;
      std::string myDriverType;
      DtElementAttributes::ElementSubtypes myElementSubtype;
      EntityStateListener::DamageState myDamageState;
      bool myElementVisible;
      bool myElementReported;
      bool myDistribute;
      ModelSetToSceneObjectIdMap myModelSetToSceneObjectIdMap;
   };

   class DT_DLL_VRVCORE DtElementCreator
   {
   public:

      DtElementCreator()
      {
         // intentional nop
      }

      virtual ~DtElementCreator()
      {
         // intentional nop
      }

      virtual DtElementCreator* clone() const = 0;

      virtual DtElement* createElement( DtBaseConnection& simulation,
         DtStateListener& listener ) const = 0;

      virtual const DtElementEntry::ElementType elementType() const = 0;

      virtual const std::string& tag() = 0;
   };

   template<typename ElementTemplateType>
   class DtElementCreatorTemplate : public DtElementCreator
   {
   public:
      // CTOR
      DtElementCreatorTemplate()
      {
         // intentional nop
      }

      virtual ~DtElementCreatorTemplate()
      {
         // intentional nop
      }

      virtual DtElementCreatorTemplate* clone() const
      {
         return new DtElementCreatorTemplate<ElementTemplateType>();
      }

      virtual DtElement* createElement( DtBaseConnection& simulation,
         DtStateListener& listener ) const
      {
         return new ElementTemplateType( simulation, listener );
      }

      virtual const DtElementEntry::ElementType elementType() const
      {
         return ElementTemplateType::theElementType();
      }

      virtual const std::string& tag()
      {
#ifdef DtDIS
         const static std::string str("DIS");
#elif DtHLA_4
         const static std::string str("HLA4");
#elif DtHLA_1516_EVOLVED
         const static std::string str( "HLA1516e" );
#elif DtHLA_1516
         const static std::string str( "HLA1516" );
#elif DtHLA
         const static std::string str( "HLA13" );
#else
         const static std::string str( "" );
#endif
         return str;
      }
   };
}