include/vrvCore/DtDeSharedState.h

Go to the documentation of this file.

/****************************************************************************** 
** Copyright (c) 2010 MAK Technologies, Inc. 
** All rights reserved. 
******************************************************************************/ 
/****************************************************************************** 
** $RCSfile: DtDeSharedState.h,v $ $Revision: 1.38 $ $State: Exp $ 
******************************************************************************/ 


#pragma once

#include <vrvCore/vrvCore.h> 

#include <vrvCore/DtDe.h>
#include <vrvCore/DtDeTimeManager.h>
#include <vrvUtil/DtVirtualBaseClass.h>
#include <vrvUtil/signalslib.h>

namespace makVrv 
{ 

   class DtCoordinateSystem;
   class DtDeSharedStateProctor;
   class DtModelDefinition;
   class DtModelDefinitionManager;
   class DtModelSetRealizationManager;
   class DtModelDefinition;

   class DT_DLL_VRVCORE DtDeSharedState 
   { 

   public:

      friend class DtDeSharedStateCreator;

      friend class DtDeSharedStateProctor;

      virtual ~DtDeSharedState();

      virtual void initialize();



      virtual const DtModelDefinitionManager& modelDefinitionManager() const;
      virtual DtModelDefinitionManager& modelDefinitionManager();

      virtual const DtModelSetRealizationManager& modelSetRealizationManager() const;

      virtual void setVisualizeModelSet( int modelset, bool visualize );

      virtual void addModelDefinition(const DtModelDefinition& definition);

      virtual void setModelDefinitionManager(
         const DtModelDefinitionManager& definition);

      virtual void renameModelDefinition(const DtModelDefinition& old,
         const DtModelDefinition& newDef);

      virtual void destroyModelDefinition(const DtModelDefinition& definition);

      virtual void setModelInstancingEnabled(bool);

      virtual void clearModelInstancingCache();




      virtual void setCoordinateSystem(const std::string& coordinateSystemName,
         const std::string& coordinateSystemParameters);

      const DtCoordinateSystem& coordinateSystem() const;
      DtCoordinateSystem& coordinateSystem();





      virtual void setDateAndTime(int year, DtDeTimeManager::Month month,
         int dayOfMonth, int hour, int minutes,double seconds);

      virtual void setTimeScale(double timeScale);

      const DtDeTimeManager& timeManager() const;




      virtual void setWireframeMode(bool state);
      virtual bool wireframeMode() const;

      virtual bool terrainScalingEnabled() const;
      virtual void setTerrainScalingEnabled(bool enabled);

      virtual double terrainScaleFactor() const;
      virtual void setTerrainScaleFactor(double scaleFactor);

      virtual bool clearTrackHistoryOnTerrainScaleChanged() const;
      virtual void setClearTrackHistoryOnTerrainScaleChanged(bool clear );

      virtual void setPlanViewGeocentricOccludedTransparency(float f);
      virtual float planViewGeocentricOccludedTransparency() const;      

      virtual void setPerformanceOverlayOn(bool enabled);
      virtual bool performanceOverlayEnabled() const;

      virtual void setShadowState(bool shadowMode, int shadowQuality, 
         bool entityMode,  bool propMode, bool terrainMode);

      virtual bool shadowMode() const;
      virtual int shadowQuality() const;
      virtual bool entityShadowMode() const;
      virtual bool propShadowMode() const;
      virtual bool terrainShadowMode() const;

      virtual void loadRenderSettings(const std::string& filepath);      
      virtual void saveRenderSettings(const std::string& filepath);
      virtual void loadDefaultRenderSettings(bool useOnlyFactorySettings);
      virtual void saveDefaultRenderSettings();
      virtual void updateRenderState();




      virtual void setDdsFlip(bool state);

      virtual bool ddsFlip() const;

      virtual void loadLoaderSettings(const std::string& filepath);      
      virtual void saveLoaderSettings(const std::string& filepath);
      virtual void loadDefaultLoaderSettings(bool useOnlyFactorySettings);
      virtual void saveDefaultLoaderSettings();
      virtual void updateLoaderState();




      virtual void setAccelerationCachingEnabled(bool enabled);

      virtual bool accelerationCachingEnabled() const;

      virtual void clearAccelerationCache() const;

      virtual void setInstancingEnabled(bool enabled);

      virtual void setClearInstancesOnNewSceneEnabled(bool enabled);

      virtual bool instancingEnabled() const;

      virtual bool clearInstancesOnNewScene() const;

      virtual void clearInstancingCache();

      virtual void setCompressTextures(bool enabled);

      virtual bool compressTextures() const;

      virtual void loadCacheSettings(const std::string& filepath);
      virtual void saveCacheSettings(const std::string& filepath);
      virtual void loadDefaultCacheSettings(bool useOnlyFactorySettings);
      virtual void saveDefaultCacheSettings();
      virtual void updateCacheState();



      virtual void initializeSharedChangeManager();



      virtual void synchronizeSlave(DtDeRecord* igRecord);




      boost::signal<void (const std::string&,const std::string&)> 
         signal_coordinateSystemChanged;

      void setAutoSave(bool b)
      {
         myAutoSave = b;
      }

      bool autoSave() const
      {
         return myAutoSave;
      }

   protected:

      DtDeSharedState(DtDe& DtDe);

      virtual void sendModelDefinitionsToSlave(DtMessageClient* messageClient);

      virtual void sendModelSetConfigurationToSlave(
         DtMessageClient* messageClient);




      virtual void local_setModelDefinitionManager(const DtModelDefinitionManager& definition);

      virtual void local_addModelDefinition(const DtModelDefinition& definition);

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

      virtual void local_setModelInstancingEnabled(bool);

      virtual void local_clearModelInstancingCache();

      virtual void local_setWireframeMode(bool mode);

      virtual void local_setTerrainScalingEnabled(bool enabled);

      virtual void local_setTerrainScaleFactor(double scaleFactor);

      virtual void local_setClearTrackHistoryOnTerrainScaleChanged(bool clear);

      virtual void local_setPlanViewGeocentricOccludedTransparency(float alpha);

      virtual void local_setShadowState(bool mode, int qual, bool entity, bool prop, bool terrain);

      virtual void local_ddsFlipState(bool flip);

      virtual void local_setVisualizeModelSet( int modelSet, bool visualize );

      void local_setCoordinateSystem(const std::string& coordinateSystemName, 
         const std::string& coordinateSystemParameters);



      void local_setDateAndTime(int year, DtDeTimeManager::Month month,int dayOfMonth,
         int hour, int minutes,double seconds);
      void local_setTimeScale(double timeScale);



      virtual void local_setAccelerationCachingEnabled(bool enabled);

      virtual void local_clearAccelerationCache();

      virtual void local_setInstancingEnabled( bool enabled );

      virtual void local_setClearInstancesOnNewScene( bool enabled );

      virtual void local_clearInstancingCache();

      virtual void local_setCompressTextures( bool enabled );


   protected:

      DtDe& myDe;
      DtDeSharedStateProctor* myIgSharedStateProctor;
      DtModelDefinitionManager* myModelDefinitionManager;
      DtModelSetRealizationManager* myModelSetRealizationManager;
      DtCoordinateSystem* myCoordinateSystem;
      DtDeTimeManager myTimeManager;

      bool myWireframeMode;
      bool myTerrainScalingEnabled;
      double myTerrainScaleFactor;
      bool myClearTrackHistoryOnTerrainScaleChanged;
      float myPlanViewGeocentricOccludedTransparency;
      bool myShadowMode;
      int myShadowQuality;
      bool myEntityShadowMode;
      bool myPropShadowMode;
      bool myTerrainShadowMode;
      bool myAutoSave;

   };

   class DT_DLL_VRVCORE DtDeSharedStateCreator : public DtVirtualBaseClass
   {

   public:

      static DtDeSharedStateCreator& instance(DtDe&);

      static void registerInstance(DtDe& de, DtDeSharedStateCreator*);

      virtual DtDeSharedState* create(DtDe& de);

   };

}