vrfFogOfWarHandler.h

Go to the documentation of this file.

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



#pragma once
 
#if DtDIS
#include <vrfDis/vrfDis.h> 
#elif DtHLA
#ifndef DtHLA_1516
#include <vrfHla13/vrfHla13.h> 
#else
#ifdef DtHLA_1516_EVOLVED
#include <vrfHla1516e/vrfHla1516e.h> 
#else
#include <vrfHla1516/vrfHla1516.h> 
#endif
#endif
#endif

#include <vrfVrlSharedSource/vrfDriver.h>

#include <vrvUtil/DtSignalConnectionManager.h>
#include <vrvCore/DtShowHideContext.h>
#include <vrfGuiNetworkCommon/vrfEntitySimDataProcessor.h>
#include <vrfGuiNetworkCommon/aggregateSimDataProcessor.h>
#include <vrfGuiNetworkCommon/environmentSimDataProcessor.h>
#include <vrfGuiNetworkCommon/vrfDataProcessorInterface.h>
#include <vrfStateData/stateData.h>
#include <tbb/spin_mutex.h>

namespace makVrv
{
   namespace DT_PROTOCOL_NAMESPACE
   {
      class DtVrlinkAggregateStateListener;
      class DtVrlinkEntityStateListener;
   }
}

namespace makVrf
{
   class DtVrfSelectionFilter;

   namespace VRF_PROTOCOL_NAMESPACE
   {
      class VRF_PROTOCOL_EXPORT DtVrfFogOfWarEntityDataProcessor : public DtVrfEntitySimDataProcessor
      {
      public:
         DtVrfFogOfWarEntityDataProcessor(DtStateDataManager*, makVrv::DtBaseConnection&);

         virtual void setState(const DtStateData*, makVrv::DtSimState& state);
      };

      class VRF_PROTOCOL_EXPORT DtVrfFogOfWarEnvironmentalDataProcessor : public DtEnvironmentSimDataProcessor
      {
      public:
         DtVrfFogOfWarEnvironmentalDataProcessor(DtStateDataManager*, makVrv::DtBaseConnection&);

         virtual void setState(const DtStateData*, makVrv::DtSimState& state);
      };

      class VRF_PROTOCOL_EXPORT DtVrfFogOfWarAggregateDataProcessor : public DtAggregateSimDataProcessor
      {
      public:
         DtVrfFogOfWarAggregateDataProcessor(DtStateDataManager*, makVrv::DtBaseConnection&);
      };

      class VRF_PROTOCOL_EXPORT DtVrfFogOfWarHandler
      {
      public:
         DtVrfFogOfWarHandler(DtVrfDriver*, makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkConnection* c);
         virtual ~DtVrfFogOfWarHandler();

         virtual void slot_addFogOfWarFilter(const DtVrfSelectionFilter*);

         virtual void slot_removeFogOfWarFilter(const std::string&);

      protected:

         virtual void executeFiltersForEntities();

         virtual void executeFiltersForEntity(const DtStateData*);

         virtual void onEntityDiscovered(DtStateData*);
         virtual void onEntityToBeDestroyed(const DtStateData*);

         virtual void entityForceIdChanged(int old, int newVal, makVrf::SimStateID);
         virtual void entityDamageStateChanged(int old, int newVal, makVrf::SimStateID);
         virtual void checkEntitiesForFOWChange();

      protected:
         virtual void executeFilters();

         virtual bool executeFilters(const makVrv::DtVrlinkSimulatedBaseState*, const makVrf::DtVrfObjectDataState*);


      protected:
         virtual void executeFiltersForTacticalGraphics(bool force = false);

         virtual void executeFiltersForEnvironmental(const DtStateData*);

         virtual void onEnvironmentalDiscovered(DtStateData*);
         virtual void onEnvironmentalToBeDestroyed(const DtStateData*);
         virtual void slot_onFirstTickDriverInitialization();
         virtual void initializeFilters();

         virtual void environmentalForceIdChanged(int old, int newVal, makVrf::SimStateID);
         virtual void environmentalExtendedDataChanged(const DtStateData*);
         virtual void checkEnvironmentalsForFOWChange();

      protected:
         virtual void executeFiltersForAggregates();

         virtual void executeFiltersForAggregate(const DtStateData*);

         virtual void onAggregateDiscovered(DtStateData*);
         virtual void onAggregateToBeDestroyed(const DtStateData*);

         virtual void aggregateForceIdChanged(int old, int newVal, makVrf::SimStateID);
         virtual void aggregateDamageStateChanged(int old, int newVal, makVrf::SimStateID);
         virtual void checkAggregatesForFOWChange();

      protected:
         struct Connection
         {
            Connection()
            {
            }

            virtual ~Connection()
            {
            }

            boost::signals2::connection myToBeDestroyedConnection;
            boost::signals2::connection myForceIdChangedConnection;
            boost::signals2::connection myDamageStateChangedConnection;
            boost::signals2::connection myExtendedDataChangedConnection;
         };

         struct EntityConnection : public Connection
         {
            EntityConnection(DtStateData* sd, DtVrfFogOfWarHandler* parent);
            EntityConnection(const EntityConnection& orig);
            virtual ~EntityConnection();
         };

         struct EnvironmentalConnection : public Connection
         {
            EnvironmentalConnection(DtStateData* sd, DtVrfFogOfWarHandler* parent);
            EnvironmentalConnection(const EnvironmentalConnection& orig);
            virtual ~EnvironmentalConnection();
         };

         typedef boost::unordered_map<Legion::UInt64, boost::shared_ptr<Connection> > Connections;
         Connections myFOWConnections;

      protected:
         DtVrfDriver*                                       myVrfDriver;
         makVrv::DT_PROTOCOL_NAMESPACE::DtVrlinkConnection* myConnection;

         typedef std::map<std::string, const DtVrfSelectionFilter*>  FogOfWarFilters;
         FogOfWarFilters                                    myFogOfWarFilters;

         makVrv::DtSignalConnectionManager myConnections;
         makVrv::DtSignalConnectionManager myEnvironmentalConnections;

         DtVrfFogOfWarEntityDataProcessor                   myEntityDataProcessor;
         DtVrfFogOfWarEnvironmentalDataProcessor            myEnvironmentalDataProcessor;
         DtVrfFogOfWarAggregateDataProcessor                myAggregateDataProcessor;
         DtVrfDataProcessorInterface*                       myEntityObjectDataProcessor;

         bool                                               myEnabledForTacticalGraphicFiltering;

         std::set<makVrf::SimStateID> myEntitiesToCheckForFOW;
         tbb::spin_mutex myEntitiesToCheckForFOWMutex;

         std::set<makVrf::SimStateID> myEnvironmentalsToCheckForFOW;
         tbb::spin_mutex myEnvironmentalsToCheckForFOWMutex;

         std::set<makVrf::SimStateID> myAggregatesToCheckForFOW;
         tbb::spin_mutex myAggregatesToCheckForFOWMutex;

         tbb::spin_mutex myFOWConnectionsMutex;
      };
   }
}