entityFacadeCollection.h

Go to the documentation of this file.

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



#pragma once

#include <vrfGuiCore/vrfGuiCore.h>
#include <vrfGuiCore/vrfObjectFacadeInterface.h>
#include <vrfGuiCore/entityStateListenerExtensions.h>

#include <vrvCore/DtBaseConnection.h>
#include <vrvCore/DtAggregateStateListener.h>
#include <vrvCore/DtSharedModelSetSettings.h>
#include <vrvCore/DtVisualizerSet.h>
#include <vrvUtil/DtUnicode.h>
#include <vrvVrl/DtForceManager.h>

#include <matrix/vlVector.h>
#include <matrix/vlTaitBryan.h>

#include <string>
#include <map>

class DtEntityType;
class DtRwColor;

namespace makVrv
{
   class DtVisualDefinitionSet;
   class DtAgentManagerInterface;
   class DtDe;
   class DtStatePropertyDecorationVisualizer;
   class DtBaseConnection;
}

namespace makVrf
{
   class DtBoundingVolumeSupportPointCalculator;

   class MyStateVisualizer : public makVrv::DtStateVisualizer
   {
   public:
      MyStateVisualizer(makVrv::DtBaseConnection& connection, makVrv::DtStateListener& listener,
         int modelSet) : makVrv::DtStateVisualizer(connection, listener, modelSet) {};

      int modelSet() const { return myModelSet; };
   };

   class DT_DLL_VRFGUICORE DtExtAggregateStateListener : public makVrv::DtAggregateStateListener, public DtEntityStateListenerExtensions
   {
   public:
      DtExtAggregateStateListener(makVrv::DtUniqueID id, makVrv::DtSharedSettingsManager& settingsManager)
      : makVrv::DtAggregateStateListener(id, settingsManager)
      ,  DtEntityStateListenerExtensions(id) {};
      virtual ~DtExtAggregateStateListener() {};
   };

   class DT_DLL_VRFGUICORE DtEntityFacadeCollection : public DtVrfObjectFacadeInterface
   {
   public:
      typedef std::map<int, makVrv::DtVisualizerSet*> ModelSetMap;

   public:
      DtEntityFacadeCollection(makVrv::DtDe&, int modelSet = -1);
      virtual ~DtEntityFacadeCollection();

   public:

      virtual void visualize(const makVrv::DtUnicode& type, 
         const makVrv::DtSharedModelSetSettings::ModelSetVisualizedMap& sets);            

      const ModelSetMap& modelSetMap() const
      {
         return myModelSetMap;
      }

      ModelSetMap& modelSetMap()
      {
         return myModelSetMap;
      }

      virtual bool isVisualized() const;

      virtual void setupNodeMaskFlags() const;

      virtual void setSetupNodeMaskFlags(bool);

      virtual std::map<int, std::vector<int> > modelStates(int modelSet) const;

      virtual std::vector<int> artParts(int modelSet) const;

      virtual void enableArtPart(int modelSet, int artPart, bool enable, const DtVector& translationRate = DtVector::zero(),
         const DtVector& rotationalRate = DtVector::zero());

      virtual void enableArtPartTranslation(int modelSet, int artPart, bool enable,
         const DtVector& translationRate = DtVector::zero(), const DtVector& minTranslation = DtVector::zero(),
         const DtVector& maxTranslation = DtVector::zero());

      virtual void enableArtPartRotation(int modelSet, int artPart, bool enable,
         const DtVector& rotationRate = DtVector::zero(), const DtVector& minRotation = DtVector::zero(),
         const DtVector& maxRotation = DtVector::zero());

      virtual void getArtPartInformation(int modelSet, int artPart, DtVector& minRotation, DtVector& maxRotation, DtVector& minTranslation, DtVector& maxTranslation);

      virtual void setModelState(int modelSet, int, int);

      virtual void setTopographicOrientation(const DtTaitBryan& orientation);

      virtual void setTopographicOffsetFromPrincipal(const DtVector&, bool resetLocation = true);

      virtual void setLocalOrientation(const DtTaitBryan& orientation);
      
      virtual void setOrigin(const DtVector& v);
      virtual void setOrigin(const DtGeodeticCoord& v);

      virtual void setOriginAndSeaLevel(const DtVector& v);
      virtual void setOriginAndSeaLevel(const DtGeodeticCoord& v);

      virtual void ignoreVisualTypeSwitch(int, bool);

      virtual bool hasOccupant() const;

      virtual void setDropShadow(bool b);
      virtual void setAltitudeOffsetFromPrincipal( double offset, bool resetLocation = true );

      virtual void setForceType(DtForceType);
      DtForceType forceType() const;
      virtual bool hasForceChange() const;

      virtual double initialAltitudeAboveTerrain() const;

      virtual makVrv::DtBaseConnection& baseConnection() const;
      
      void setHatLineVisible( bool visible );
      
      void setTrackHistoryVisible( bool visible );

      virtual void setVisible(bool b, bool updateOffsets = true);
      virtual void setVisible(bool, int context);
      virtual bool isVisible() const;

      virtual void setUseHighestTerrainLod(bool);

      virtual void setPickable(bool b);

      virtual void setSelected(bool b);

      virtual void setLabel(const std::string& label);
      virtual std::string label() const;
      virtual bool hasLabelChange() const;

      virtual void setExtendedLabels(const std::map<int, DtString>& labels);
      virtual std::map<int, DtString> extendedLabels() const;
      virtual bool hasExtendedLabelsChange() const;

      virtual void setOverlayName(const std::string&);
      virtual std::string overlayName() const;

      virtual void setIndicatorVisible(bool b);

      virtual Dt3dBoundingVolume boundingVolume(int modelSet = 0) const;

      virtual void calculateSupportPoints(int modelSet, DtVector& left, DtVector& right, DtVector& other) const;

      virtual void setAttachedTo(DtVrfObjectFacadeInterface*, const DtVector& offset, const DtTaitBryan&);
      virtual void detach();

      virtual void setUniqueID(makVrv::DtUniqueID);
      virtual makVrv::DtUniqueID uniqueID() const;
      virtual std::vector<makVrv::DtUniqueID> modelUniqueIDs() const;

      virtual void clearMarkingsModified();
      virtual bool markingsModified() const;

      virtual void setMarkingDecal(const std::string& annotation, const std::string& value);
      virtual std::string markingDecal(const std::string& annotation) const;
      const std::map<std::string, std::string>& markingDecalMap() const
      {
         return myMarkingDecals;
      }

      virtual void clearMarkingDecals();

      virtual bool hasMultipleLODs(int modelSet = 0) const;

      virtual void setWidgetEventsEnabled(bool b);

      virtual void setGroundClamping(bool b);
      virtual void setDeadReckoning(bool position, bool velocity, bool orientation);

      virtual void setSymbolDecorationOffset(double x, double y);

      virtual void setAutoEnableGroundClamping(bool b);

      virtual void realizeFacades();

      virtual void unrealizeFacades(bool willRecreate = false);

      virtual void setDictionaryToDisplay(int);
      bool dictionaryToDisplay() const { return myDictionaryToDisplay; };

      virtual bool hasProjectedModel(int modelSet) const;

      virtual void setElementDefinition(const makVrv::DtUnicode& elementName);      
      
      virtual const makVrv::DtUnicode& elementDefinition() const;

      virtual void setElementDefinition(const DtEntityType&);

      void setSmoothingEnabled(bool enabled);

      void setMotionModel(const std::string&);

      virtual void setLabelIndicatorVisible(bool);

      virtual void setHeadingIndicatorVisible(bool);

      virtual void setHeadingIndicatorSize(float l);

      virtual bool isDiGuy() const { return myIsDiGuy; };

      virtual DtVector position() const;

      virtual makVrv::DtUniqueID uniqueIDForModelSet(int set) const;

      virtual void setEffectsVisible(bool);

      virtual bool shouldEnableTrailEffects() const;

      virtual void enableTrailEffect(bool);

      virtual void setAltitudeAboveTerrain(double d);

      virtual void setAltitudeAboveSeaLevel(double d);

      virtual bool hasWakeModel(int set);
      virtual void setWakeLOD(double);
      virtual void setShowWakes(bool b, int modelSet = -1);

      virtual void setShowSmoke(bool b, int modelSet = -1);
      virtual void setShowFlames(bool b, int modelSet = -1);

      virtual void setShowOccupants(bool b);

      virtual const DtVector32& velocity() const;
      virtual void setVelocity(const DtVector32& v);

      template <typename T> void visualizers(int modelSet, std::vector<T>& visualizers) const
      {
         if (myModelSetMap.find(modelSet) == myModelSetMap.end())
         {
            return;
         }

         myModelSetMap.find(modelSet)->second->findVisualizersByDynamicCast(visualizers);
      }

      template <typename T> bool hasVisualizer(makVrv::DtVisualizerSet* s) const
      {
         if (!s)
         {
            return false;
         }

         std::vector<T> visualizers;
         s->findVisualizersByDynamicCast(visualizers);
         
         return (visualizers.size() != 0);
      }

      virtual void setIconScale(float);
      template <typename T> void setIconScale(makVrv::DtVisualizerSet* s, float scale)
      {
         std::vector<T> visualizers;
         s->findVisualizersByDynamicCast(visualizers);            
         typename std::vector<T>::iterator i = visualizers.begin();
         typename std::vector<T>::iterator e = visualizers.end();
         for(;i != e; ++i)
         {
            if (*i)
            {
               (*i)->setIconScale(scale);
            }
         }
      }

      virtual void setExtendedData(const std::map<std::string, std::string>&);
      virtual std::map<std::string, std::string> extendedData() const;

      virtual void destroySchema(const makVrv::DtVisualizerSchema&);

      virtual void setEntityExtents(const DtVector& volume, const DtVector& offset);

      virtual bool hasBoundingVolumes() const;

      virtual void setEntityExtentsVisible(bool, int modelSet = -1);
      template <typename T> void setEntityExtentsVisible(makVrv::DtVisualizerSet* s, bool b, int modelSet = -1)
      {
         std::vector<T> visualizers;
         s->findVisualizersByDynamicCast(visualizers);            
         typename std::vector<T>::iterator i = visualizers.begin();
         typename std::vector<T>::iterator e = visualizers.end();
         for(;i != e; ++i)
         {
            if (*i)
            {
               if ((modelSet == -1) || (modelSet == ((MyStateVisualizer*)(*i))->modelSet()))
               {
                  (*i)->setVisible(b);
               }
            }
         }
      }

      template <typename T> void setScale(makVrv::DtVisualizerSet* s, float scale)
      {
         std::vector<T> visualizers;
         s->findVisualizersByDynamicCast(visualizers);            
         typename std::vector<T>::iterator i = visualizers.begin();
         typename std::vector<T>::iterator e = visualizers.end();
         for(;i != e; ++i)
         {
            if (*i)
            {
               (*i)->setScale(scale);
            }
         }
      }

      template <typename T> void setForceColor(makVrv::DtVisualizerSet* s, makVrv::DtForceManager::RGBAColor color)
      {
         std::vector<T> visualizers;
         s->findVisualizersByDynamicCast(visualizers);            
         typename std::vector<T>::iterator i = visualizers.begin();
         typename std::vector<T>::iterator e = visualizers.end();
         for(;i != e; ++i)
         {
            if (*i)
            {
               (*i)->setForceColor(color.R, color.G, color.B, color.A);
            }
         }
      }

      template <typename T> void setForceType(makVrv::DtVisualizerSet* s, DtForceType type)
      {
         std::vector<T> visualizers;
         s->findVisualizersByDynamicCast(visualizers);            
         typename std::vector<T>::iterator i = visualizers.begin();
         typename std::vector<T>::iterator e = visualizers.end();
         for(;i != e; ++i)
         {
            if (*i)
            {
               (*i)->setForceId(type);
            }
         }
      }

      template <typename T> void setColor(makVrv::DtVisualizerSet* s, makVrv::DtForceManager::RGBAColor color)
      {
         std::vector<T> visualizers;
         s->findVisualizersByDynamicCast(visualizers);            
         typename std::vector<T>::iterator i = visualizers.begin();
         typename std::vector<T>::iterator e = visualizers.end();
         for(;i != e; ++i)
         {
            if (*i)
            {
               (*i)->setColor(color.R, color.G, color.B, color.A);
            }
         }
      }

      virtual void setForceColor(const DtRwColor&);
      void setBoundingExtentColor(float r, float g, float b, float a);

      virtual std::string diGuyCharacter() const;

      virtual std::string diGuyAppearance() const;

      virtual std::string diGuyHandItem() const;
      virtual std::string diGuyHead() const;

      virtual void setAppearance(int);
      virtual DtAppearance appearance() const;

      virtual void setLifeFormState(unsigned int, bool paused = false);
      virtual void setCharacterWeaponAiming(bool aiming);
      virtual void setEnableAnimationSmoothing(bool);
      virtual void setCharacterAction(const std::string& animation, bool paused = false);
      virtual const std::string& characterAction() const;

      virtual void setCharacterModel(const std::string& animation);
      virtual std::string characterModel() const;

      virtual void setCharacterBodyWeight(double);
      virtual void setCharacterAlive(bool);

      virtual void setCharacterAppearance(const std::string& animation);
      virtual void setCharacterHandItem(const std::string& item);
      virtual void setCharacterHead(const std::string& head);

      virtual void setDisplayName( const std::string& displayName );

      virtual void setSymbolNameVisible(bool);

      virtual void setStatePropertyDecorationsVisible(bool);

      virtual void setSymbolDecorationsVisible(bool);

      virtual bool isAggregate() const
      {
         return myIsAggregate;
      }

      virtual void finalizeSetup();

      virtual void updateSymbolRotation(const DtTaitBryan&);

      virtual void updateSymbolRotation(double);

      virtual void setRotateToHeading(bool);
      bool rotateToHeading() const
      {
         return myRotateToHeading;
      }

      virtual void slot_visualizerCreationDisabled( int modelSet, int visualType );
      virtual void slot_visualizerCreationEnabled( int modelSet, int visualType );

      boost::signals2::signal<void (DtEntityFacadeCollection*)> signal_orientationChanged;

   protected:
      makVrv::DtUnicode                      myElementDefinition;

      bool mySetupNodeMaskFlags;
      makVrv::DtBaseConnection* myConnection;

      DtExtAggregateStateListener         myListener;
      ModelSetMap myModelSetMap;

      std::string myOverlay;
      bool myIsAggregate;
      bool myHasLabelChange;
      bool myHasExtendedLabelsChange;
      bool myForceChanged;
      DtForceType myForceType;
      int myAppearance;

      std::string myDiGuyAppearance;
      std::string myDiGuyHandItem;
      std::string myDiGuyHead;
      std::string myCharacterAction;
      std::string myCharacterModel;
      double myDiGuyBodyWeight;
      bool myCharacterPaused;

      bool myIsDiGuy;
      bool myShowOccupants;
      bool myOriginSet;
      bool myNeedsRealization;
      bool myIndicatorVisible;
      bool myHatLinesVisible;
      bool myEnableAnimationSmoothing;
      bool myUseHighestTerrainLOD;
      bool myHeadingIndicatorVisible;
      bool myTrackHistoryVisible;
      bool mySymbolNameVisible;
      bool myEntityExtentsVisible;
      int myDictionaryToDisplay;
      int myAttributeCompareValue;
      bool myMarkingsModified;
   
      typedef std::map<int, std::map<int, int> > ActivatedStates;
      ActivatedStates myActivatedStates;

      mutable DtBoundingVolumeSupportPointCalculator* myBVSPCalculator;

      bool myRotateToHeading;

      makVrv::DtSignalConnectionManager myConnections;
      boost::signals2::connection myFinalizeConnection;

      std::map<std::string, std::string> myMarkingDecals;
      std::map<int, std::map<int, bool> > myEffectsShown;

      std::set<int> myIgnoreVisualTypeSwitch;
   };

   class DT_DLL_VRFGUICORE DtEntityFacadeCollectionCreator : public makVrv::DtVirtualBaseClass
   {
   public:
      DtEntityFacadeCollectionCreator(makVrv::DtDe& de);
      virtual ~DtEntityFacadeCollectionCreator();

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

      virtual DtEntityFacadeCollection* create(int modelSet = -1);

   protected:
      makVrv::DtDe& myDe;
   };
}