terrainProfileRequestManager.h

Go to the documentation of this file.

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

#pragma once

#include "vrfobjcore/vrfobjcoreDefines.h"

#include <matrix/vlMath.h>
#ifdef WIN32
#include <WinSock2.h>
#endif
#include <tbb/spin_mutex.h>
#include <tbb/tbb_thread.h>
#include <tbb/atomic.h>
#include <tbb/compat/condition_variable>
#include "vrfmsgs/ifIntersectionInformationResponse.h"

#include <vector>


class DtSimManager;
class DtSimMessage;
class DtSimInterfaceMessage;

class DT_DLL_vrfobjcore DtTerrainProfileRequestManager
{
public:

   DtTerrainProfileRequestManager(DtSimManager * simManager);

   virtual ~DtTerrainProfileRequestManager();

   virtual bool init();

   virtual void tick();

   virtual void terrainClosed();

protected:

   static void terrainProfileInformationRequestCallback(DtSimMessage* msg, void* usr);
   virtual void processTerrainProfileInformationRequest(DtSimInterfaceMessage* msg);

   static void cancelTerrainProfileInformationRequestCallback(DtSimMessage* msg, void* usr);
   virtual void processCancelTerrainProfileInformationRequest(DtSimInterfaceMessage* msg);

   virtual void processTerrainRequestInformation();

private:
   DtTerrainProfileRequestManager(const DtTerrainProfileRequestManager & orig);

   const DtTerrainProfileRequestManager & operator=(const DtTerrainProfileRequestManager & orig);

protected:
   DtSimManager*  mySimManager;

   std::auto_ptr<tbb::tbb_thread> myTerrainProcessInformationThread;
   typedef tbb::interface5::condition_variable Condition;
   typedef tbb::mutex ConditionMutex;
   typedef tbb::interface5::unique_lock<ConditionMutex> ConditionLock;
   mutable Condition myTerrainProcessInformationCondition;
   mutable ConditionMutex myTerrainProcessInformationConditionMutex;
   tbb::atomic<bool> myShutdownTerrainProcessInformationFlag;
   tbb::atomic<bool> myClearPendingIntersections;
   tbb::atomic<bool> myProcessed;

   tbb::spin_mutex myTerrainProcessInformationAdditionMutex;

   struct TerrainInformationRequest
   {
      TerrainInformationRequest() : requestId(0), sendPartial(true) {};
      TerrainInformationRequest(int r, bool s = true, const std::vector<DtVector>& p = std::vector<DtVector>()) :
         requestId(r), sendPartial(s), points(p) {};
      TerrainInformationRequest(const TerrainInformationRequest& orig) : requestId(orig.requestId), sendPartial(orig.sendPartial), points(orig.points) {};
      int requestId;
      bool sendPartial;
      std::vector<DtVector> points;
   };

   typedef std::vector<TerrainInformationRequest> TerrainInformationRequests;
   TerrainInformationRequests myTerrainInformationRequests;

   struct TerrainInformationResult : public TerrainInformationRequest
   {
      TerrainInformationResult() {};
      TerrainInformationResult(const TerrainInformationRequest& orig) : TerrainInformationRequest(orig) {};
      TerrainInformationResult(const TerrainInformationResult& orig) : TerrainInformationRequest(orig), allResults(orig.allResults) {};

      struct Result
      {
         Result() : soilType(0xFFFFFFFF), terrainHeight(0.) {};
         Result(const Result& orig) : soilType(orig.soilType), terrainHeight(orig.terrainHeight), testPoint(orig.testPoint) {};

         unsigned int soilType;
         DtVector testPoint;
         double terrainHeight;
      };

      typedef std::map<int, Result> Results;

      Results allResults;
   };

   typedef std::map<int, TerrainInformationResult> TerrainInformationResults;
   TerrainInformationResults myTerrainInformationResults;

   typedef std::map<int, DtIfIntersectionInformationResponse> ResultsToSend;
   ResultsToSend myResultsToSend;
};