DtDe.h

Go to the documentation of this file.

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

#include <vrvCore/DtDeCommunicator.h>
#include <vrvCore/DtDisplayProxy.h>

#include <vrvUtil/DtMainEventQueue.h>

#include <vlutil/vlThreadSysWrapper.h>

#include <vector>

#include <boost/bind.hpp>

#define DT_DE_INIT_ONCE(de)\
if(de.isInitFunctionRegistered((void*)&init))\
{\
  return;\
}\
else\
{\
   de.registerInitFunction((void*)&init);\
}

class DtClock;

namespace makVrv 
{ 
   class DtAgentManager;
   class DtDataBank;
   class DtDeProctor;
   class DtDeSharedState;
   class DtDisplay;
   class DtDriverManager;
   class DtFileCache;
   class DtMessageDispatcher;
   class DtProctor;
   class DtRenderer;
   class DtScene;
   class DtVirtualBaseClass;
   class DtSchemaManager;
   class DtStatsSet;
   class DtDeError;
   class DtDisplayConfiguration;
   class DtWindowConfiguration;
   class DtChannelConfiguration;
   class DtDriverConfiguration;
   class DtSynchronizedTimeManager;

   class DT_DLL_VRVCORE DtDe
   {
   public:    

      friend class DtDeProctor;

      typedef std::vector<std::pair<DtDeError,bool> > DeErrors;
   
   public:

      DtDe();

      virtual ~DtDe();

      bool destructing();

      virtual void setDeInitializer(const DtDeInitializer& initializer);

      virtual void setPathConfiguration(const DtDePathConfiguration& pathConfig);

      enum InitializationResult
      {
         Initialized = 1,
         UnableToInitialize = 0,
         UnableToInitializeDueToLicense = -1
      };

      virtual InitializationResult initialize( bool abortOnLicenseFailure = true, bool useLicenseErrorDialog=true );

      bool initialized() const;

      DtThreadId threadId();

      virtual void setDeConfiguration(const DtDeConfiguration& deConfig);

      virtual void tick(double simTime);

      inline void retick() { tick(simulationTime()); }

      virtual bool timeToStop() const;

      virtual void setTimeToStop(bool flag = true);

      virtual void quit();

      virtual void reset();

      void updateScene();



      virtual const DtDeConfiguration& deConfiguration() const;

      virtual DtDeCommunicator& igCommunicator();

      DtMainEventQueue& mainEventQueue();

      virtual DtDisplay* display();
  
      virtual DtScene& scene();

      virtual DtDataBank& dataBank();

      virtual DtDriverManager& driverManager();
      
      bool driverManagerCreated() const;

      virtual DtMessageDispatcher& dispatcher();

      inline DtDebugLog& log() { return myDebugLog; }

      DtAgentManager& agentManager();

      bool agentManagerCreated() const;
  
      virtual double simulationTime() const;

      virtual double syncedTime() const;

      virtual DtSynchronizedTimeManager* findSynchronizedTimeManager();

      virtual int displayCount() const;  

      virtual const DtDeInitializer& deInitializer() const;

      virtual const DtDePathConfiguration& dePathConfiguration() const;

      virtual bool isInMasterMode() const;

      virtual bool isInSlaveMode() const;

      virtual DtDeSharedState& sharedState();

      virtual const DtSchemaManager& schemaManager() const;
      virtual DtSchemaManager& schemaManager();

      virtual DtFileCache* fileCache();

      virtual const DeErrors& deErrors() const;

      virtual void clearDeErrors();

      virtual DtRenderer& renderer() const;

      bool renderFrameThisTick() const;

      virtual bool licenseAvailable() const;



 
      virtual bool addDisplayConfiguration(const DtDisplayConfiguration&);

      virtual void realizeDisplayConfiguration(const std::string& clientName,
         const std::string& displayName);

      virtual void destroyDisplay(DtDisplayProxySP display);

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

      virtual void destroyAllDisplays();

      virtual bool modifyDisplay( const std::string& displayName, 
         const DtDisplayConfiguration& config );
     



      virtual void setSimulationTime(double time);

      virtual double systemTime() const;

      typedef DtVirtualBaseClass& (*StaticInstanceFunction)(DtDe&);

      virtual DtVirtualBaseClass* findFastInstance(
         StaticInstanceFunction classInstanceFunction) const;

      template <typename Class>      
      DtVirtualBaseClass* findFastInstance(Class& (*staticInstFunc)(DtDe&)) const
      {
         return findFastInstance(reinterpret_cast<StaticInstanceFunction>(staticInstFunc));
      }

      virtual void registerFastInstance(
         StaticInstanceFunction classInstanceFunction, DtVirtualBaseClass* inst);

      template <typename Class>      
      void registerFastInstance(Class& (*staticInstFunc)(DtDe&),DtVirtualBaseClass* inst)
      {
         registerFastInstance(reinterpret_cast<StaticInstanceFunction>(staticInstFunc),inst);
      }

      virtual DtVirtualBaseClass* findInstance(
         const std::string& instanceName) const;

      virtual void registerInstance(const std::string& instanceName, 
         DtVirtualBaseClass* instance);

      virtual void registerProctor(unsigned short handlerId,DtProctor*);

      virtual void unregisterProctor(unsigned short handlerId);

      DtProctor* findProctor(unsigned short handlerId) const;

      DtDisplayProxySP findDisplay(const std::string& displayName );

      virtual DtDisplayProxySP findDisplayByIndex(int index);

      void setRenderFrameThisTick(bool update);

      virtual bool isValidDisplayConfiguration( const DtDisplayConfiguration& dec );


      //


      boost::signal<void ()> signal_initializeDefaultState;

      boost::signal<void ()> signal_postInitialize;

      boost::signal<void (DtDe&)> signal_preTick;

      boost::signal<void ()> signal_postTick;

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

      boost::signal<void (const DtDisplayConfiguration&)> signal_displayConfigurationAdded;

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

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

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

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

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

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

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

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

      boost::signal<void (const DtDeError& error, bool critical)> signal_deError;

      boost::signal<void ()> signal_quit;


      //


      virtual void onSlaveConnected(const std::string& igName);

      virtual void emitDeError(const DtDeError& error, bool criticalError);

  
      static const char* className(); 

      void registerInitFunction(void* address);

      bool isInitFunctionRegistered(void* address);      

      inline bool shouldSendMesssage()
      {
         return isInMasterMode() && myCommunicator && !myCommunicator->masterIgOnly();
      }

      inline void setPagedLodMagnificationScaleFactor( float factor )
      {
         myPagedLodMagnificationScaleFactor = factor;
      }

      inline float pagedLodMagnificationScaleFactor() const
      {
         return myPagedLodMagnificationScaleFactor;
      }

   protected:



      virtual unsigned int countEmbeddedWindows( const DtDisplayConfiguration &dec );


      
      virtual void initializeSchemaManager();

      virtual void initializeLibXmlIfNecessary();

      virtual bool shouldSkipThisTick( double simulationTime );

      virtual void postInitialize();

      virtual void postInitializeMaster();

      virtual void checkForData();
      

      //Default implementation of a slave's tick.
      void slaveTick();

      //Default implementation of a master's tick.
      void masterTick( double simulationTime );

      void renderTick();

      DtDeProctor* proctor();

      virtual bool local_realizeDisplayConfiguration(
         const std::string& clientName, const std::string& displayName);

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

      virtual bool local_modifyDisplay( const std::string& displayName,
         const DtDisplayConfiguration& config );

      void createDisplay(DtDisplayConfiguration&);

      void createIgCommunicator( DtDriverConfiguration& config);

      void destroyDisplay();
    
      bool local_addDisplayConfiguration( const DtDisplayConfiguration& dec);


   
   protected:

      typedef std::vector<void*> InitFunctionVector;

      // Normal map here since add/remove order matters for destruction order
      typedef std::map<std::string,DtVirtualBaseClass*> RootedSingletonMap;
      typedef std::map<StaticInstanceFunction,DtVirtualBaseClass*> FastRootedSingletonMap;

      typedef std::map<std::string,DtDisplayProxyWP> DisplayEngineProxyMap;

   protected:

      static const char* myClassName;

      RootedSingletonMap myRootedSingletonMap;
      FastRootedSingletonMap myFastRootedSingletonMap;
      DtDeInitializer myInitializer;
      DtDePathConfiguration myPathConfiguration;
      bool myStopFlag;      
      bool myInitializeFlag;
      double mySimulationTime;
      double myNextFixedTime;
      DtDebugLog myDebugLog;
      DtDeConfiguration myConfiguration;      
      DtMainEventQueue myMainEventQueue;
      DtDisplay* myDisplayEngine;
      DtDeCommunicator* myCommunicator;
      DtMessageDispatcher* myDispatcher;
      DtDeProctor* myIgProctor;
      DtDriverManager* myDriverManager;
      DtAgentManager* myAgentManager;
      DisplayEngineProxyMap myDisplayProxies;
      DtDeSharedState* myDeSharedState;
      DtDataBank* myDataBank;
      DtSchemaManager* mySchemaManager;
      
      InitFunctionVector myRegisteredInitFunctions;
      void* myRegInitFunction;
      
      DtFileCache* myFileCache;
      DeErrors myIgErrors;
      DtRenderer* myRenderer;     
      bool mySceneNeedsUpdateFlag;
      bool myDestructionFlag;
      bool myInTickFlag;

      mutable std::string myLastInstanceName;
      mutable RootedSingletonMap::const_iterator myLastInstance;

      DtThreadId myThreadId;

      DtClock* mySimulationClock;
      DtSynchronizedTimeManager* mySynchronizedTimeManager;

      enum LicenseTypes
      {
         NoLicense = -1,
         Master3D_License = 0,
         XR_License = 1,
         PVD_License = 2
      };

      LicenseTypes myLicenseType;

      //temporary until this becomes a render setting (maybe)
      float myPagedLodMagnificationScaleFactor;
      float myPagedLodMagnificationHighLodAngle;
   }; 


   template <typename ManagerClass>
   void defaultManagerRegisterInstanceFunction(DtDe& de, ManagerClass* mgr);

   template <typename ManagerClass>
   ManagerClass& defaultManagerInstanceFunction(DtDe& de, bool allowedInSlave)
   {
      ManagerClass* mgr = dynamic_cast<ManagerClass*>
         (de.findFastInstance(&ManagerClass::instance));

      if(!mgr)
      {
         //Require that manager is created before de is initialized.
         if(de.initialized())
         {
            DtTHROW_NEW(DtCorruptedState,
               "Manager created after display engine was initialized.");
         }

         if(!allowedInSlave && de.isInSlaveMode())
         {
            DtTHROW_NEW(DtCorruptedState, "Create unsupported manager in slave.");
         }

         //Create and register the manager.
         mgr = new ManagerClass(de);
         defaultManagerRegisterInstanceFunction(de,mgr);
      }
      return *mgr;
   }

   template <typename ManagerClass>
   void defaultManagerRegisterInstanceFunction(DtDe& de, ManagerClass* mgr)
   {
      //Always override before init.
      if(de.initialized())
      {
         DtTHROW_NEW(DtCorruptedState,
            "Manager created after display engine was initialized.");
      }

      de.registerFastInstance(&ManagerClass::instance,mgr);

      mgr->myConnections.manageConnection(
         de.signal_initializeDefaultState.connect(boost::bind(
         &ManagerClass::loadDefaults,mgr)));
   }

}