vrfNavAreaManager.h

Go to the documentation of this file.

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



#pragma once

#include <vrfNavigation/navArea.h>

#include <vrfobjcore/vrfobjcoreDefines.h>
#include <terrainInterface/terrainImplementation.h>

#include <matrix/vlVector.h>
#include <matrix/coordTransform.h>

#include <geometry/extent.h>
#include <geometry/point.h>

#include <readerWriter/noArgumentCallbackList.h>

#include <tbb/spin_mutex.h>
#include <tbb/task_arena.h>
#include <tbb/task_group.h>

#include <atomic>
#include <map>
#include <queue>
#include <vector>
#include "vrfutil/rwTerrainCategoryMask.h"


class DtTerrainInterface;
class DtSimManager;
class DtSimObject;
class DtLocalVertexList;
class DtSimMessage;
class Coordinate_System;
class DtUUID;
class DtAttachedTerrain;
class DtLocalObject;
class DtNavGenerationThreadCounter;
class DtSimulationServices;
class DtTerrainAttachedTo;

namespace makArchives
{
   class DtGenericTerrainRecord;
}

typedef void (*DtNavAreaRemovalCallbackFcn)(DtNavArea* area,
   void* usr);

class DT_DLL_vrfobjcore DtVrfNavAreaManager
{
public:
   
   DtVrfNavAreaManager(DtSimulationServices* manager);

   virtual ~DtVrfNavAreaManager();

   static void tickCallback(void* args);

   virtual bool init();

   virtual void tick();


   virtual void setTerrainInterface(DtTerrainInterface* terrainInterface);
   virtual DtTerrainInterface* terrainInterface()
   {
      return myTerrainInterface;
   }


   static void genericRecordLoadedCallback(
      makArchives::DtGenericTerrainRecord* record, void *user);
   virtual void processGenericRecordLoaded(
      makArchives::DtGenericTerrainRecord* record);


   void loadObjectNavData(const DtSimObject* simObject, const DtReaderWriter::SearchPaths& searchPaths = DtReaderWriter::SearchPaths());
   void removeObjectNavData(const DtSimObject* simObject);
   DtNavArea* areaForObject(const DtSimObject* simObject) const;

   virtual void unloadAllNavData();

   virtual void revertNavData();

   virtual void pauseNavDataRegeneration();
   
   virtual void resumeNavDataRegeneration();

   virtual void addNavArea(DtNavArea* a);

   virtual DtNavArea* loadNavArea(DtNavArea::NavAreaId id, const DtFilename& filename);

   virtual DtNavArea* loadNavDataForObject(DtNavArea::NavAreaId id, const DtFilename& filename,
      const DtSimObject* simObject, const DtReaderWriter::SearchPaths& searchPaths = DtReaderWriter::SearchPaths());

   virtual void loadAllNavData(bool* dataAvailable = 0);

   virtual DtNavArea::NavAreaId nextNavAreaId();


   virtual DtNavArea* findNavAreaForLocation(const DtVector& localPosition, const DtString& profile,
      const DtSimObject* = 0, bool* dataAvailable = 0);
   virtual std::vector<DtNavArea*> findNavAreasForLocation(const DtVector& localPosition, 
      const DtString& profile, DtTerrainCategoryMask terrainCategoryMask, 
      const DtSimObject* = 0, bool* dataAvailable = 0, const DtAttachedTerrain* terrainAttachedTo = 0,
      bool loadNavAreas = true);
   virtual std::vector<DtNavArea*> findNavAreasForArea(const DtLocalVertexList* boundingArea,
      const DtString& profile, const DtSimObject* = 0, bool* dataAvailable = 0);
   virtual DtNavArea* findNavAreaForArea(const DtLocalVertexList* area, const DtString& profile,
      const DtSimObject* = 0, bool* dataAvailable = 0);

   virtual std::vector<DtNavArea*> findNavAreasForLocation(const DtVector& localPosition) const;

   virtual void addNavAreaAboutToBeRemovedCallback(
      DtNavAreaRemovalCallbackFcn fcn, void* usrData) const;

   virtual void removeNavAreaAboutToBeRemovedCallback(
      DtNavAreaRemovalCallbackFcn fcn, void* usrData) const;

   virtual void setBlockingNavDataLoad(bool b);


   static void requestNavAreaStatusCallback(DtSimMessage*, void* usr);
   virtual void processRequestNavAreaStatus();


   static void requestSimObjectDebugPortsCallback(DtSimMessage* msg, void* usr);
   virtual void processRequestSimObjectDebugPortsCallback(DtUUID uuid);

   virtual void sendNavDataStatus();

   virtual void processNavQueues();


   static void setGamewareWorkingMemorySize(int sizeInMb);
   static void setRegenerateNavigationDataAtRuntime(bool regen);
   static void setMaxRegenerationThreads(int threads);
   static void setNumberOfNavQueueProcessingThreads(int threads);
   static void setRegenerationDelay(double delay);
   static void setQueryTimeBudget(double ms);
   static void setRegenerationFileDirectory(const DtFilename& dir);

   static int theGamewareWorkingMemorySize;
   static bool theRegenerateNavDataAtRuntime;
   static int theMaxRegenerationThreads;
   static int theNumberOfNavQueueProcessingThreads;
   static double theRegenerationDelay;
   static double theQueryTimeBudget;
   static DtFilename theRegenerationFileDirectory;

   virtual void processSimObjectDeleted(const DtSimObject* simObject);

   virtual void invokeAreaAboutToBeDeletedCallbacks(DtNavArea*);


   static void navigationRegenUpdateCallback(void* usr);
   virtual void processNavigationRegenUpdate();
   
   void processUnloadTerrain();

   virtual void updateSimOperationStatus();

   void setBlockOnAsynchronousOperations(bool block);

   bool hasAsynchronousOperationsPending() const;

protected:


   static void terainChangeNotificationCallback(const DtTerrainChangeNotificationInfo& terrainChangeInfo, void* usr);
   void processTerrainChangeNotification(const DtTerrainChangeNotificationInfo& terrainChangeInfo);

   virtual void processNavAreasTerrainChangesQueues();

protected:
   DtTerrainInterface* myTerrainInterface;

   //the extents and their data for all the unloaded nav areas in this terrain
   struct navAreaExtentData
   {
      DtFilename filename;

      DtPoint ReferencePoint;
      std::shared_ptr<DtCoordTransform> Matrix;
      DtDcm LocalCorrectionMatrix;
      DtDcm InvLocalCorrectionMatrix;
      DtCoordTransform InvMatrix;
      std::set<DtString> Profiles;
      bool IsLoading;
      DtExtent* Extent;
      DtDynamicTerrainQueryHandle DynamicTerrainQuery;
      boost::signals2::connection DynamicTerrainConnection;
   };

   std::map<DtNavArea::NavAreaId, navAreaExtentData> myNavAreaExtents;



   //the nav areas whose data has been loaded
   typedef std::vector<DtNavArea*> DtNavAreas;
   DtNavAreas myNavAreas;

   typedef std::map<DtUUID, DtNavArea*> DtObjectNavAreaMap;
   DtObjectNavAreaMap myObjectNavAreas;

   typedef std::queue<DtTerrainChangeNotificationInfo> DtNavAreaTerrainChangesQueue;
   typedef std::map<DtNavArea::NavAreaId, DtNavAreaTerrainChangesQueue*> DtNavAreasTerrainChangesQueues;
   typedef std::map<DtNavArea::NavAreaId, DtExtent> DtNavAreasLocalExtents;

   DtNavAreasTerrainChangesQueues myNavAreasTerrainChangesQueues;

   DtNavAreasLocalExtents myNavAreasLocalExtents;

   bool myRegisteredForTerrainChanges;

   bool myNavigationInitialized;
   DtSimulationServices* mySimulationServices;
   Coordinate_System* myObjectCoordSys;

   bool myBlockingNavLoad;

   DtNavArea::NavAreaId myNextNavAreaId;

public:
   DtNavGenerationThreadCounter* myNavGenThreadCounter;
protected:

   typedef DtCallbackList<DtNavArea*> NavAreaAboutToBeRemovedList;
   mutable NavAreaAboutToBeRemovedList myNavAreaAboutToRemRemovedList;
   tbb::spin_mutex myNavAreaExtentsMutex;
   mutable tbb::spin_rw_mutex myNavAreaMutex;
   mutable tbb::spin_rw_mutex myObjectNavAreaMutex;

   DtVrfCallbackQueue* myNavQueryProcessingParallelQueue;
   std::atomic<bool> myContinueProcessing;
   std::atomic<bool> myProcessingStopped;

   tbb::task_arena myNavAreaArena; 
   tbb::task_group myNavAreaTaskGroup;
   boost::signals2::connection myUnloadTerrainConnection;

   bool myRegenInTempDirectory;
   bool myNavRegenerating = false;
   bool myNavOperations = false;
};