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 <vrfExtObjects/dynamicTerrainPublisher.h>
#include <vrfExtObjects/terrainGeometry.h>
#include <vrfExtObjects/keyValuePair.h>
#include <vl/detonationInteraction.h>
#include <vrfmsgs/ifRequestDynamicTerrainInformation.h>
#include <vrfmsgs/ifDynamicTerrainInformationResponse.h>

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

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, DtVrfObject* owner,
      DtSimManager* simManager, DtComponentDescriptor* desc=0, DtReaderWriterRegistry *parentRegistry=0);

   virtual ~DtDynamicTerrainController();

   virtual bool init();

   virtual void registerCallbacks();

   virtual void deregisterCallbacks();

   virtual void preFirstTickInit();

   virtual const char* type() const;

   virtual void tick();

   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 DtRwDynamicTerrainItem* findDynamicTerrainSwitch(const DtTerrainGeometry& geometry,
      double tolerance, const DtString& key, unsigned* index = 0);

   static DtSimComponent* creator(const DtString& name, DtVrfObject* owner, DtSimManager* simManager,
      DtComponentDescriptor* desc=0, DtReaderWriterRegistry* parentRegistry=0);

   virtual void updateTaskVisualizations();

   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);

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);

   virtual bool isRequestValidForArea(const DtIfRequestDynamicTerrainInformation& req);

   virtual bool isCommandValidForArea(const DtDynamicTerrainCommand& cmd);

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

   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;
   };

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

   virtual bool processPendingDynamicTerrainInformation(PendingDynamicTerrainInformationPtr&);

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

   virtual DtDynamicTerrainPublisher* createPublisher();

   virtual DtDynamicTerrainControllerPSR* createPSR();

   virtual void addPublishedChange(std::vector<DtDynamicTerrainPublisher*>& publishers,
      const DtTerrainGeometryAndData& change);

   virtual void updatePublishedChange(std::vector<DtDynamicTerrainPublisher*>& publishers, 
      unsigned index, const DtKeyValuePairList& changeData, unsigned priority, unsigned eventNumber);

   virtual const DtTerrainGeometryAndData& publishedChange(const std::vector<DtDynamicTerrainPublisher*>& publishers,  unsigned index) const;


protected:

   DtDynamicTerrainControllerDescriptor* myDynamicTerrainDescriptor;

   DtDynamicTerrainControllerPSR* myProcessState;

   std::vector<DtDynamicTerrainPublisher*> myIndividualSwitchPublishers;

   std::vector<DtDynamicTerrainPublisher*> myAreaPublishers;

   PendingDynamicTerrainRequests myPendingDynamicTerrainRequests;
   double myDynamicTerrainRecheckPeriod;

   double myLastTickRealTime;

   typedef tbb::spin_mutex 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;

};