DtStateVisualizer.h

Go to the documentation of this file.

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


#pragma once

#include <vrvCore/vrvCore.h>
#include <vrvCore/DtUniqueID.h>
#include <vrvCore/DtShowHideContext.h>
#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvUtil/DtUnicode.h>

namespace makVrv
{
   class DtSceneObjectAgent;
   class DtBaseConnection;
   class DtStateListener;
   class DtVisualizerDefinition;
   class DtVisualizerSchema;
   enum class DtModelSetId;

   class DT_DLL_VRVCORE DtStateVisualizer
   {

   public:
      enum Type
      {
         AllVisualizerTypes = 0,
         EntityVisualizerType = 1,
         EnvironmentalVisualizerType,
         InteractionVisualizerType,
         AggregateVisualizerType,
         IntervisibilityVisualizerType,
         TacticalSmokeVisualizerType,
         UserType = 10000
      };

      struct DT_DLL_VRVCORE TypeInfo
      {
         TypeInfo(const std::string& fname,
            const DtUnicode& sname, 
            DtStateVisualizer::Type type,
            const DtVisualizerSchema& s)
         : functionalTypeName(fname)
         , screenName(sname)
         , supportedVisualizerType(type)
         , schema(s)
         {
         }

         const std::string functionalTypeName;
         const DtUnicode screenName;
         const DtStateVisualizer::Type supportedVisualizerType;
         const DtVisualizerSchema& schema;
      };

   public:
      DtStateVisualizer( DtBaseConnection& connection, DtStateListener& listener,
         DtSceneObjectAgent* sceneObjectAgent, DtModelSetId modelSet );

      virtual ~DtStateVisualizer();

      virtual DtModelSetId modelSet();

      virtual void createModelAgents() = 0;

      virtual void destroyModelAgents() = 0;

      virtual const TypeInfo& typeInfo() const = 0;

      virtual void setSceneObjectAgent( DtSceneObjectAgent* sceneObject );

      void setModelDefinition(const std::string& definition);

      const std::string& modelDefinition() const;


      virtual void implementVisibility(bool visible);

      virtual void initialize();

      virtual void slot_setSelected(bool b) {}

      void setName(const std::string&);
      const std::string& name() const;

      virtual void setPickable(bool);
      virtual bool pickable() const;


      virtual DtUniqueID sceneObjectID() const
      {
         return mySceneObjectID;
      }

      int visualizerType() const
      {
         return myVisualizerType;
      }

      virtual void setVisualizerDefinition(const DtVisualizerDefinition&);

      //Get the listener for this visualizer.
      inline DtStateListener& listener()
      {
         return myListener;
      }

      inline const DtStateListener& listener() const
      {
         return myListener;
      }

      inline DtBaseConnection& simulation()
      {
         return mySimulation;
      }

      void setDistribute(bool b)
      {
         myDistributeFlag = b;
      }

      bool distribute() const
      {
         return myDistributeFlag;
      }

      virtual bool isVisible() const;

      virtual bool setVisualizerIsVisible(bool vis, DtVisualizerShowHideContext::VisualizerShowHideContext context);

   protected:

      virtual void setModelDefinitionForAgents() = 0;
      
      virtual void connectToListenerSignals();

      virtual void makeVisible();


      virtual void setInitialValuesFromVisualizerDefinition();

      template <typename T, typename C>
      void connectAndUpdate(boost::signalslib::signal<void (T)>& sig,void (C::*fp)(T),T val)
      {
         myConnections.manageConnection(sig.connect(boost::bind(fp, 
            static_cast<C*>(this), boost::placeholders::_1)));
         //Call this connection.
         ((C&)(*this).*fp)(val);
      }

   private:
      DtStateVisualizer() = delete;

      DtStateVisualizer( const DtStateVisualizer& ) = delete;

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

   protected:
      
      DtBaseConnection& mySimulation;
      DtStateListener& myListener;

      bool myDistributeFlag;

      DtUniqueID mySceneObjectID;
      std::string myName;
      std::string myModelDefinition;
      DtSignalConnectionManager myConnections;
      DtModelSetId myModelSet;
      int myVisualizerType;
      bool myPickable;
      bool myVisible;          
      const DtVisualizerDefinition* myVisualizerDefinition;
      DtSceneObjectAgent* mySceneObjectAgent;      
      bool myInitialInitializeDone;
      typedef std::vector<DtVisualizerShowHideContext::VisualizerShowHideContext> ShowHideContextVector;
      ShowHideContextVector myVisualizerShowHideContexts;

   };

   class DT_DLL_VRVCORE DtStateVisualizerCreator
   {
   public:

      DtStateVisualizerCreator()
      {
      }

      virtual ~DtStateVisualizerCreator()
      {
      }

      virtual DtStateVisualizerCreator* clone() const = 0;

      virtual DtStateVisualizer* create( DtBaseConnection& simulation,
         DtStateListener& listener, DtSceneObjectAgent* sceneObjectAgent, DtModelSetId modelSet ) const = 0;

      virtual const DtStateVisualizer::TypeInfo& visualizerTypeInfo() const = 0;

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

   };

   template <typename StateVisualizer>
   class DtStateVisualizerCreatorTemplate : public DtStateVisualizerCreator
   {
   public:

      DtStateVisualizerCreatorTemplate()
      {
      }

      virtual ~DtStateVisualizerCreatorTemplate()
      {
      }

      virtual DtStateVisualizerCreator* clone() const
      {
         return new DtStateVisualizerCreatorTemplate<StateVisualizer>();
      }

      virtual DtStateVisualizer* create( DtBaseConnection& simulation,
         DtStateListener& listener, DtSceneObjectAgent* sceneObjectAgent, DtModelSetId modelSet ) const
      {
         return new StateVisualizer( simulation, listener, sceneObjectAgent, modelSet );
      }

      virtual const DtStateVisualizer::TypeInfo& visualizerTypeInfo() const
      {
         return StateVisualizer::theTypeInfo();
      }

      virtual const std::string& tag()
      {
         static const std::string theEmptyString;
         return theEmptyString;
      }
   };

}