dynamicTerrainController.h

Go to the documentation of this file.

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



#pragma once

#include <vrfmodel/vrfmodelDefines.h>
#include <vrfobjcore/singleTaskControllerComponent.h>
#include <vrfExtProtocol/terrainGeometry.h>
#include <vrfExtProtocol/keyValuePair.h>
#include <vrfmsgs/ifRequestDynamicTerrainInformation.h>
#include <vrfmsgs/ifDynamicTerrainInformationResponse.h>
#include <vrfmodel/dynamicTerrainStateComponentUtils.h>

class DtDynamicTerrainControllerDescriptor;
class DtDynamicTerrainControllerPSR;
class DtRwDynamicTerrainItem;
class DtSimCommand;
class DtDynamicTerrainCommand;
class DtAddDynamicTerrainChangesCommand;
class DtSwitchDynamicTerrainAtPointCommand;
class DtResetDynamicTerrainChangesCommand;
class DtResetAllDynamicTerrainChangesCommand;
class DtTerrainGeometryAndData;
class DtRwVectorList;
class DtKeyValuePairList;
class DtWorldLocationStructArray;

namespace makVrf
{
   class DtDynamicTerrainStateComponent;
}

namespace makVrv
{
   class DtDynamicTerrainFeature;
   class DtDynamicTerrainChanges;
   class DtDynamicTerrainGeometry;
}

class DT_DLL_vrfmodel DtDynamicTerrainController : public DtSingleTaskControllerComponent
{
private:
   DtDynamicTerrainController();
   DtDynamicTerrainController(const DtDynamicTerrainController& orig);
   DtDynamicTerrainController& operator=(const DtDynamicTerrainController& orig);

public:
   DtDynamicTerrainController(const DtString& name, DtLocalObject* owner,
      DtSimulationServices* simManager, DtComponentDescriptor* desc=nullptr, DtReaderWriterRegistry *parentRegistry=nullptr);

   virtual ~DtDynamicTerrainController();

   virtual bool init() override;

   virtual void registerCallbacks();

   virtual void deregisterCallbacks();

   virtual void preFirstTickInit() override;

   virtual const char* type() const override;

   virtual void tick() override;

   virtual bool processDynamicTerrainSwitch(const DtTerrainGeometry& geometry, const DtKeyValuePair& change,
      unsigned priority, double delay = 0.0, bool shouldQueue = true);

   virtual void processDynamicTerrainArea(const DtTerrainGeometry& geometry, const DtKeyValuePairList& changes,
      unsigned priority, double delay = 0.0);

   virtual void processDynamicTerrainCrater(const DtTerrainGeometry& geometry, const DtKeyValuePairList& changes,
      unsigned priority, double delay = 0.0);

   virtual DtRwDynamicTerrainItem* findDynamicTerrainSwitch(const DtTerrainGeometry& geometry,
      double tolerance, const DtString& key, unsigned* index = nullptr);

   static DtSimComponent* creator(const DtString& name, DtLocalObject* owner, DtSimulationServices* simManager,
      DtComponentDescriptor* desc = nullptr, DtReaderWriterRegistry* parentRegistry = nullptr);

   virtual void updateTaskVisualizations() override;

   virtual void processQueuedTerrainChanges(double dt);

   virtual void setDynamicTerrainInformationRecheckPeriod(double);
   virtual double dynamicTerrainInformationRecheckPeriod() const
   {
      return myDynamicTerrainRecheckPeriod;
   }

   virtual std::list<DtVector> findDynamicTerrainElements(const DtVector& localLocation, double radius,
      const DtString& filterKey = DtString::nullString(),
      std::list<DtRwDynamicTerrainInformation>* fullInfo = 0,
      bool* dataAvailable = 0);

   virtual std::list<DtVector> findDynamicTerrainElements(const DtVector& localStartLocation,
      const DtVector& localEndLocation, const DtString& filterKey = DtString::nullString(),
      std::list<DtRwDynamicTerrainInformation>* fullInfo = 0,
      bool* dataAvailable = 0);

   virtual const DtDynamicTerrainControllerDescriptor* dynamicTerrainDescriptor();

protected:

   virtual void updateSingleSwitch(const DtTerrainGeometry& geometry, const DtKeyValuePair& change,
      unsigned priority);

   static void addDynamicTerrainChangesCallback(const DtSimCommand& cmd, void* usr);
   virtual void processAddDynamicTerrainChangesCommand(const DtAddDynamicTerrainChangesCommand& cmd);

   static void switchDynamicTerrainCallback(const DtSimCommand& cmd, void* usr);

   virtual bool processSwitchDynamicTerrainCommand(const DtSwitchDynamicTerrainAtPointCommand& cmd, bool shouldQueue = true);

   static void resetDynamicTerrainChangesCallback(const DtSimCommand& cmd, void* usr);
   virtual void processResetDynamicTerrainChangesCommand(const DtResetDynamicTerrainChangesCommand& cmd);

   static void resetAllDynamicTerrainChangesCallback(const DtSimCommand& cmd, void* usr);
   virtual void processResetAllDynamicTerrainChangesCommand(const DtResetAllDynamicTerrainChangesCommand& cmd);

   virtual bool isRequestValidForArea(const DtIfRequestDynamicTerrainInformation& req);

   virtual bool isCommandValidForArea(const DtDynamicTerrainCommand& cmd);

   virtual bool isInCommandGeometry(const DtDynamicTerrainCommand& cmd, const DtTerrainGeometry& terrainGeometry);

   virtual bool isRedundantChange(const DtTerrainGeometry& geometry, const DtKeyValuePairList& changes, double tolerance) const;

   DtVector averageLocation(const DtRwVectorList& vectorList) const;
   DtVector averageLocation(const DtWorldLocationStructArray& vectorList) const;

   static void dynamicTerrainInformationRequestCallback(DtSimMessage*, void* usr);
   virtual void processDynamicTerrainInformationRequest(DtIfRequestDynamicTerrainInformation*);

   struct PendingDynamicTerrainInformation
   {
      DtIfRequestDynamicTerrainInformation request;
      DtIfDynamicTerrainInformationResponse response;
      double nextCheckTime;
   };

   using PendingDynamicTerrainInformationPtr = DtBoost::shared_ptr<PendingDynamicTerrainInformation>;
   typedef std::vector<PendingDynamicTerrainInformationPtr> PendingDynamicTerrainRequests;

   virtual bool processPendingDynamicTerrainInformation(PendingDynamicTerrainInformationPtr&);

   static void drawDynamicTerrainCallback(DtSimMessage * msg, void * usr);
   virtual void processDrawDynamicTerrainTask(DtSimMessage * msg);

   virtual DtDynamicTerrainControllerPSR* createPSR();

   virtual void addChangeToStateComponents(std::vector<makVrf::DtDynamicTerrainStateComponent*>& publishers,
      const DtTerrainGeometryAndData& change);

protected:

   const DtDynamicTerrainControllerDescriptor* myDynamicTerrainDescriptor;

   DtDynamicTerrainControllerPSR* myProcessState;

   std::vector<makVrf::DtDynamicTerrainStateComponent*> myIndividualSwitchPublishers;

   std::vector<makVrf::DtDynamicTerrainStateComponent*> myAreaPublishers;

   std::vector<makVrf::DtDynamicTerrainStateComponent*> myCraterPublishers;

   std::vector<makVrf::DtDynamicTerrainStateComponent*> myVehicleTrackPublishers;

   PendingDynamicTerrainRequests myPendingDynamicTerrainRequests;
   double myDynamicTerrainRecheckPeriod;

   double myLastTickRealTime;

   using Mutex = tbb::spin_mutex;
   mutable Mutex myTerrainFeatureMutex;

   struct QueuedTerrainSwitch
   {
      QueuedTerrainSwitch(const DtTerrainGeometry& g, const DtKeyValuePair& c, unsigned p, double d)
         : geometry(g.clone()), change(c), priority(p), delay(d) {};

      ~QueuedTerrainSwitch()
      {
         delete geometry;
      }

      DtTerrainGeometry* geometry;
      DtKeyValuePair change;
      unsigned priority;
      double delay;
   };
   std::list<QueuedTerrainSwitch> myTerrainSwitchQueue;
   std::list<DtSwitchDynamicTerrainAtPointCommand> myTerrainSwitchAtPointQueue;
   bool myEnabled;
};