DtVisualizerSet.h

Go to the documentation of this file.

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


#pragma once 

#include <vrvCore/DtShowHideContext.h>
#include <vrvCore/DtStateVisualizer.h>
#include <vrvCore/DtVisualizerCreationSettings.h>
#include <vrvCore/DtMouseState.h>

#include <vrvCore/DtVisualizerSchema.h>

namespace makVrv
{
   class DtBaseConnection;
   class DtSceneObjectVisualizer;
   class DtStateListener;
   class DtStateVisualizerFactory;
   class DtElementDefinitionNew;
   class DtVisualizerDefinitionSet;
   class DtVisualizerDefinition;
   class DtSceneObjectAgent;

   class DT_DLL_VRVCORE DtVisualizerSet
   {
   public:

      typedef std::vector<DtStateVisualizer*> VisualizerList;

      DtVisualizerSet(DtBaseConnection& conn, DtStateListener& listener, 
         int modelSet, bool distribute);

      DtVisualizerSet( DtBaseConnection& conn, DtStateListener& listener,
         DtSceneObjectAgent* sceneObject, int modelSet, bool distribute );

      virtual ~DtVisualizerSet();

      virtual void visualizeElementDefinition(const DtUnicode& elementName, 
         const DtElementDefinitionNew& def, 
         const DtVisualizerCreationSettings::VisualTypeVisualizerCreationMap& creationMap );

      virtual void visualizeElementDefinition(const DtUnicode& elementName, 
         const DtElementDefinitionNew& def);

      virtual void createVisualizersByType( int visualType );

      virtual void destroyVisualizersByType( int visualType );

      const DtElementDefinitionNew* definition() const;
      virtual void setElementDefinition( const DtElementDefinitionNew* def );

      int modelSet() const;
      
      template <typename VisualizerClass>
      inline void findVisualizers(std::vector<VisualizerClass*>& visualizers);
      
      template <typename VisualizerClass>
      inline void findVisualizersByDynamicCast(std::vector<VisualizerClass*>& visualizers);

      virtual void findVisualizers(const DtVisualizerSchema&,
         VisualizerList& visualizers);

      virtual DtUniqueID sceneObjectID() const;

      DtSceneObjectVisualizer* sceneObjectVisualizer() const;

      virtual void setPickable( bool pickable );

      bool pickable() const;

      virtual bool addVisualizer(const DtVisualizerDefinition& def);
    
      virtual void destroyAllModelVisualizers();

      virtual DtStateVisualizer::Type supportsVisualizerType() const;

      DtStateListener& listener() const;

      virtual void setVisible(bool visible, DtVisualizerShowHideContext::VisualizerShowHideContext);

   protected:
      void destroyAllModelVisualizersInternal();
   public:
      virtual void visualizeVisualizerDefinitionSet(const DtUnicode& elementName,
         const DtVisualizerDefinitionSet& set,
         const  DtVisualizerCreationSettings::VisualTypeVisualizerCreationMap* creationMap = nullptr);
   protected:
      virtual DtStateVisualizer* createVisualizerFromDefinition(const DtVisualizerDefinition& def);

      virtual void addVisualizer(const std::string& schemaName, 
         DtStateVisualizer* visualizer);

      virtual bool suppressVisualizerCreation( const DtVisualizerDefinition* visDef,
         const  DtVisualizerCreationSettings::VisualTypeVisualizerCreationMap* 
         creationMap) const;

      virtual int findVisualType( const DtVisualizerDefinition& visDef ) const;

     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), _1)));
        ((C&)(*this).*fp)(val);
     }

   protected:

      const DtUnicode* chooseRandomString(const std::vector<DtUnicode>& stringList);

   protected:
      typedef boost::unordered_multimap<std::string,DtStateVisualizer* >StateVisualizerMap;

      DtBaseConnection& myBaseConnection;
      DtStateVisualizerFactory& myCachedFactory;
      DtStateListener& myStateListener;
      StateVisualizerMap myVisualizers;
      DtSignalConnectionManager myConnections;
      const DtElementDefinitionNew* myDefinition;

      bool myPickable;
      bool myVisible;
      bool myDistribute;

      DtSceneObjectAgent* mySceneObjectAgent;
      // XXX old way to be removed eventually
      DtSceneObjectVisualizer* mySceneObjectVisualizer;
      typedef std::vector<DtShowHideContext::ShowHideContext> ShowHideContexts;

      ShowHideContexts myShowHideContexts;
      int myModelSet;

      std::string myVisualTypeString;
   };

   template <typename VisualizerClass>
   inline void DtVisualizerSet::findVisualizers(
      std::vector<VisualizerClass*>& visualizers)
   {
      std::pair<StateVisualizerMap::iterator,
         StateVisualizerMap::iterator> range = myVisualizers.equal_range(
         VisualizerClass::theTypeInfo().schema.name());
         
      for(; range.first != range.second; ++range.first)
      {
         VisualizerClass* instance = dynamic_cast<VisualizerClass*>(
            range.first->second);
         if(instance)
         {
            visualizers.push_back(instance);
         }
      }
   }

   template <typename VisualizerClass>
   inline void DtVisualizerSet::findVisualizersByDynamicCast(
      std::vector<VisualizerClass*>& visualizers)
   {
      StateVisualizerMap::const_iterator iter = myVisualizers.begin();

      for(; iter != myVisualizers.end(); ++iter)
      {
         VisualizerClass* instance = dynamic_cast<VisualizerClass*>(iter->second);

         if (instance)
         {
            visualizers.push_back(instance);
         }
      }
   }
}