environmentConditionRemoteNetInterface.h

Go to the documentation of this file.

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



#pragma once

#include "vrlinkNetworkInterface/vrlinkNetworkInterfaceDefines.h"
#include "vrlinkNetworkInterface/simRemoteEnvironmentalNetInterface.h"
#include <vrfStateData/environmentalLocationStateComponent.h>
#include <vrfStateData/vrfGeometryStateComponent.h>
#include <vrfStateData/subsurfaceStateComponent.h>
#include <vrfStateData/stateData.h>
#include <vlpi/metocEnums.h>
#include <tbb/spin_mutex.h>

//#include <vl/reflectedWeatherHLA.h>

class DtTroposphereLayerStateRepository;
class DtSubsurfaceLayerStateRepository;
class DtLandSurfaceStateRepository;
class DtWaterSurfaceStateRepository;
class DtEnvironmentConditionStateRepository;

namespace makVrf
{

   class DtTroposphereStateComponent;
   class DtSubsurfaceStateComponent;
   class DtLandSurfaceStateComponent;
   class DtWaterSurfaceStateComponent;
   class DtSubsurfaceStateComponent;

   enum DtEnvironmentConditionType
   {
      DtEnvironmentConditionType_Unknown = -1,
      DtEnvironmentConditionType_Troposphere = 0,
      DtEnvironmentConditionType_LandSurface = 1,
      DtEnvironmentConditionType_WaterSurface = 2,
      DtEnvironmentConditionType_Subsurface = 3,
      DtEnvironmentConditionType_MAK_Troposphere = 4,
      DtEnvironmentConditionType_MAK_LandSurface = 5,
      DtEnvironmentConditionType_MAK_WaterSurface = 6,
      DtEnvironmentConditionType_MAK_Subsurface = 7,
      DtMaxEnvironmentConditionType
   };
   class DT_DLL_vrlinkNetworkInterface DtEnvironmentConditionRemoteNetInterface : public DtSimRemoteEnvironmentalNetInterface
   {

   private:

      DtEnvironmentConditionRemoteNetInterface();
      DtEnvironmentConditionRemoteNetInterface(const DtEnvironmentConditionRemoteNetInterface& orig);
      const DtEnvironmentConditionRemoteNetInterface& operator=(
         const DtEnvironmentConditionRemoteNetInterface& orig);
   public:

      DtEnvironmentConditionRemoteNetInterface(
         DtStateData* vrfObject, DtVrlinkNetworkInterface*, bool publishObject = true);

      virtual ~DtEnvironmentConditionRemoteNetInterface();


      virtual void onTick() override;


#if DtHLA
      virtual RTI::ObjectClassHandle objectClassHandle() const override;

#endif

      virtual DtString type() const override;

      static DtSimObjectNetInterface* creator(
         DtStateData* vrfObject, DtVrlinkNetworkInterface*, bool publishObject);

      template<typename T, typename V>
      void setReflectedObject(T* ro)
      {
         if (myObject != ro)
         {
            removeBaseUpdateCallback();
            myObject = ro;
            setEnvironmentConditionTypeFromObject(ro);
            //setup
            myObject->baseAddPostUpdateCallback(reflectedObjectUpdateCallbackFunction, this);
            setUpdateReceived(true);
            setupFromNetworkRepository<V>();

         }
      };

      virtual void clearReflectedObject(bool shouldRemoveStateComponent = true);
      static void reflectedObjectUpdateCallbackFunction(DtReflectedObject* obj, void* userData);

   protected:
      template<typename T>
      T* getVrfStateComponent()
      {
         return nextFrameVrfObject()->nextFrameState()->getStateComponent<T>();
      };      
      
      template<typename T>   
      bool hasStateComponent()
      {
         return nextFrameVrfObject()->hasStateComponent<T>();
      };
      
      template<typename T>   
      T* createVrfStateComponent()
      {
         return nextFrameVrfObject()->addStateComponent<T>(mySimObject->isLocal(), !mySimObject->isLocal());
      };
      template<typename T>
      T* getOrCreateVrfStateComponent()
      {
         return !nextFrameVrfObject()->hasStateComponent<T>() ? createVrfStateComponent<T>() : getVrfStateComponent<T>();
      };

      void removeStateComponent();

      template<typename T>
      void setupFromNetworkRepository()
      {
         initializeRemoteStateComponents<T>();
         updateFromReflectedObject();
      };

      template<typename T>
      void initializeRemoteStateComponents()
      {
         switch (myEnvironmentConditionType)
         {
         case DtEnvironmentConditionType_Troposphere:
         case DtEnvironmentConditionType_LandSurface:
         case DtEnvironmentConditionType_WaterSurface:
         case DtEnvironmentConditionType_Subsurface:
            getOrCreateVrfStateComponent<DtEnvironmentalLocationStateComponent>();
            getOrCreateVrfStateComponent<DtVrfGeometryStateComponent>();
            break;
         }
         myStateComponent = getOrCreateVrfStateComponent<T>();
      };

      virtual void updateFromReflectedObject();
      virtual int mapMetocCloudTypeToVrvCloudType(DtCloudTypeEnum32) const;
      virtual int mapHazeTypeToObscurant(DtHazeTypeEnum32 type) const;
      virtual DtVrfWeatherPrecipitationType mapMetocPrecipitationTypeToVrfPrecipitationType(DtPrecipitationTypeEnum32) const;
      virtual makVrf::DtTroposphereStateComponent* updateTroposphere(const DtTroposphereLayerStateRepository* stateRep, bool shouldSetDefaultsForMakExtensions = true);
      virtual void updateMAKTroposphere(const DtTroposphereLayerStateRepository* stateRep);
      virtual void updateFromMetocGeoreference(const DtEnvironmentConditionStateRepository* stateRep);
      virtual makVrf::DtSubsurfaceStateComponent* updateSubsurface(const DtSubsurfaceLayerStateRepository* stateRep, bool shouldSetDefaultsForMakExtensions = true);
      virtual void updateMAKSubsurface(const DtSubsurfaceLayerStateRepository* stateRep);
      virtual makVrf::DtLandSurfaceStateComponent* updateLandSurface(const DtLandSurfaceStateRepository* stateRep, bool shouldSetDefaultsForMakExtensions = true);
      virtual void updateMAKLandSurface(const DtLandSurfaceStateRepository* stateRep);
      virtual makVrf::DtWaterSurfaceStateComponent* updateWaterSurface(const DtWaterSurfaceStateRepository* stateRep, bool shouldSetDefaultsForMakExtensions=true);
      virtual void updateMAKWaterSurface(const DtWaterSurfaceStateRepository* stateRep);
      virtual void removeBaseUpdateCallback();
      virtual DtReflectedObject* reflectedObject() const;

      virtual void setEnvironmentConditionType(DtEnvironmentConditionType type);
      virtual DtEnvironmentConditionType environmentConditionType() const;

      virtual void setEnvironmentConditionTypeFromObject(DtReflectedObject* obj);
   protected:
      DtReflectedObject* myObject;
      DtEnvironmentConditionType myEnvironmentConditionType;
      DtFrameStateInterface* myStateComponent;
      static std::unordered_map<std::string, DtEnvironmentConditionType> theHLAClassNameToEnvironmentConditionTypeMap;

      typedef std::map<DtVrlUuid, double> DtAltitudeByUuidMapType;
      DtAltitudeByUuidMapType myTroposphereLayerAltitudeByUuidMap;
      DtVrfSubsurfaceLayer myLastSubsurfaceLayer;
public:

      static const int DtGlobalWeatherPriority;
      static const int DtDefaultWeatherPriority;

      tbb::spin_mutex myTroposphereLayerAltitudeByUuidMapMutex;
   };




}