DtDe.h

Go to the documentation of this file.

/****************************************************************************** 
** Copyright (c) 2010 MAK Technologies, Inc. 
** All rights reserved. 
******************************************************************************/ 
/****************************************************************************** 
** $RCSfile: DtDe.h,v $ $Revision: 1.110 $ $State: Exp $ 
******************************************************************************/ 
 
 
#pragma once
#include <vrvCore/vrvCore.h>
#include <vrvUtil/DtDebugLog.h>
#include <vrvCore/DtDeCommunicator.h>
#include <vrvCore/DtDisplayProxy.h>
#include <vrvUtil/DtDeConfiguration.h> 
#include <vrvUtil/DtDeError.h>
#include <vrvUtil/DtDeInitializer.h>
#include <vrvUtil/DtDePathConfiguration.h>
#include <vrvUtil/DtMainEventQueue.h>
#include <vlutil/vlUtil.h>
#include <vlutil/vlThread.h>
#include <vlutil/vlPerformanceStats.h>
#include <boost/signal.hpp>
#include <boost/bind.hpp>
#include <map>
#include <string>

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

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 DT_DLL_VRVCORE DtDe
   {
   public:    

      friend class DtDeProctor;

      struct TimeStat
      {
         std::string myDescription;
         DtTimeStatistic myStatistic;
      };

      struct StatsSet
      {

         void addStats(const std::string& name)
         {
            TimeStat stat = {name,DtTimeStatistic()};
            myStats.push_back(stat);
         }

         std::vector<TimeStat> myStats;
         double myTotalTime;
      };

      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 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; }

      DtPerformanceStats& stats();

      DtAgentManager& agentManager();
  
      virtual double simulationTime() const;

      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 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);


      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();
      }

      const StatsSet& lastTickStatistics() const;

   protected:



      virtual void postInitialize();

      //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;

      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;
      DtPerformanceStats myStats;
      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;

      StatsSet myLastTickStats;
      DtTimedSection myBetweenTicksTimedSection;
      DtThreadId myThreadId;
   }; 


   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)));
   }

}